1/*
2 * AFCS_MODEL1_mid.h
3 *
4 * Code generation for model "AFCS_MODEL1_sf".
5 *
6 * Model version : 1.995
7 * Simulink Coder version : 8.10 (R2016a) 10-Feb-2016
8 * C source code generated on : Wed Aug 11 17:17:39 2021
9 *
10 * Target selection: rtwsfcn.tlc
11 * Note: GRT includes extra infrastructure and instrumentation for prototyping
12 * Embedded hardware selection: ARM Compatible->ARM Cortex
13 * Emulation hardware selection:
14 * Differs from embedded hardware (MATLAB Host)
15 * Code generation objectives: Unspecified
16 * Validation result: Not run
17 *
18 * SOURCES: AFCS_MODEL1_sf.c AFCS_MODEL1_CodeReuseSubsystem.c
19 */
20
21#include "simstruc.h"
22#include "AFCS_MODEL1_sf.h"
23#if defined(MATLAB_MEX_FILE) || defined(RT_MALLOC)
24
25static int_T RegNumInputPorts(SimStruct *S, int_T nInputPorts)
26{
27 _ssSetNumInputPorts(S,nInputPorts);
28 return true;
29}
30
31static int_T RegNumOutputPorts(SimStruct *S, int_T nOutputPorts)
32{
33 _ssSetNumOutputPorts(S,nOutputPorts);
34 return true;
35}
36
37static int_T FcnSetErrorStatus(const SimStruct *S, DTypeId arg2)
38{
39 static char msg[256];
40 if (strlen(ssGetModelName(S)) < 128) {
41 sprintf(msg,
42 "S-function %s does not have a tlc file. It cannot use macros that access regDataType field in simstruct.",
43 ssGetModelName(S));
44 } else {
45 sprintf(msg,
46 "A S-function does not have a tlc file. It cannot use macros that access regDataType field in simstruct.");
47 }
48
49 ssSetErrorStatus(S, msg);
50 UNUSED_PARAMETER(arg2);
51 return 0;
52}
53
54#endif
55
56/* Instance data for model: AFCS_MODEL1 */
57void *AFCS_MODEL1_malloc(SimStruct *rts)
58{
59 /* Local SimStruct for the generated S-Function */
60 LocalS *lS = (LocalS *) malloc(sizeof(LocalS));
61 ss_VALIDATE_MEMORY(rts,lS);
62 (void) memset((char *) lS, 0,
63 sizeof(LocalS));
64 ssSetUserData(rts, lS);
65
66 /* block I/O */
67 {
68 void *b = malloc(sizeof(B_AFCS_MODEL1_T));
69 ss_VALIDATE_MEMORY(rts,b);
70 ssSetLocalBlockIO(rts, b);
71 (void) memset(b, 0,
72 sizeof(B_AFCS_MODEL1_T));
73
74 {
75 ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->FixPtSwitch = (0ULL);
76 ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Output = (0ULL);
77 ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->FixPtSum1 = (0ULL);
78 ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Quaternions[0] = 0.0F;
79 ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Quaternions[1] = 0.0F;
80 ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Quaternions[2] = 0.0F;
81 ((B_AFCS_MODEL1_T *) ssGetLocalBlockIO(rts))->Quaternions[3] = 0.0F;
82 }
83 }
84
85 _ssSetConstBlockIO(rts, &AFCS_MODEL1_Invariant);
86
87 /* previous zero-crossing states */
88 {
89 int_T i;
90 ZCSigState *zc = (ZCSigState *) malloc(sizeof(PrevZCX_AFCS_MODEL1_T));
91 ss_VALIDATE_MEMORY(rts,zc);
92 _ssSetPrevZCSigState(rts, zc);
93 for (i = 0; i < 2; i++) {
94 zc[i] = UNINITIALIZED_ZCSIG;
95 }
96 }
97
98 /* model checksums */
99 ssSetChecksumVal(rts, 0, 3122258030U);
100 ssSetChecksumVal(rts, 1, 1365478836U);
101 ssSetChecksumVal(rts, 2, 3803939167U);
102 ssSetChecksumVal(rts, 3, 1395178863U);
103
104 {
105 /* child S-Function registration */
106 ssSetNumSFunctions(rts, 170);
107
108 /* register each child */
109 {
110 SimStruct *childSFunctions;
111 SimStruct **childSFunctionPtrs;
112 childSFunctions = (SimStruct *) malloc(170 * sizeof(SimStruct));
113 ss_VALIDATE_MEMORY(rts,childSFunctions);
114 (void) memset((void *)childSFunctions, 0,
115 170*sizeof(SimStruct));
116 childSFunctionPtrs = (SimStruct **) malloc(170 * sizeof(SimStruct *));
117 ss_VALIDATE_MEMORY(rts,childSFunctionPtrs);
118 _ssSetSFunctions(rts, childSFunctionPtrs);
119
120 {
121 int_T i;
122 for (i = 0; i < 170; i++) {
123 _ssSetSFunction(rts, i, &childSFunctions[i]);
124 }
125 }
126
127 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S174>/Generated S-Function (LagFilter_sf) */
128 {
129 SimStruct *childS = ssGetSFunction(rts, 0);
130
131 /* timing info */
132 time_T *sfcnPeriod;
133 time_T *sfcnOffset;
134 int_T *sfcnTsMap;
135 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
136 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
137 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
138 ss_VALIDATE_MEMORY(rts,sfcnOffset);
139 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
140 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
141 (void) memset((void*)sfcnPeriod, 0,
142 sizeof(time_T)*1);
143 (void) memset((void*)sfcnOffset, 0,
144 sizeof(time_T)*1);
145 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
146 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
147 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
148
149 /* Set up the mdlInfo pointer */
150# ifdef USE_RTMODEL
151
152 {
153 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
154 struct _ssBlkInfo2));
155 ss_VALIDATE_MEMORY(rts,blkInfo2);
156 ssSetBlkInfo2Ptr(childS, blkInfo2);
157 }
158
159 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
160
161# else
162
163 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
164
165# endif /* USE_RTMODEL */
166
167 /* Allocate memory of model methods 2 */
168 {
169 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
170 malloc(sizeof(struct _ssSFcnModelMethods2));
171 ss_VALIDATE_MEMORY(rts,methods2);
172 ssSetModelMethods2(childS, methods2);
173 }
174
175 /* Allocate memory of model methods 3 */
176 {
177 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
178 malloc(sizeof(struct _ssSFcnModelMethods3));
179 ss_VALIDATE_MEMORY(rts,methods3);
180 ssSetModelMethods3(childS, methods3);
181 }
182
183 /* Allocate memory for states auxilliary information */
184 {
185 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
186 (sizeof(struct _ssStatesInfo2));
187 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
188 malloc(sizeof(ssPeriodicStatesInfo));
189 ss_VALIDATE_MEMORY(rts,statesInfo2);
190 ssSetStatesInfo2(childS, statesInfo2);
191 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
192 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
193 }
194
195 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
196 RegNumInputPorts);
197 ssSetRegNumInputPortsFcnArg(childS,childS);
198
199 /* inputs */
200 {
201 struct _ssPortInputs *inputPortInfo =
202 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
203 ss_VALIDATE_MEMORY(rts,inputPortInfo);
204 _ssSetNumInputPorts(childS, 6);
205 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
206
207 /* port 0 */
208 {
209 real32_T const **sfcnUPtrs = (real32_T const **)
210 malloc(1 * sizeof(real32_T *));
211 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
212 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
213 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
214 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
215 _ssSetInputPortNumDimensions(childS, 0, 1);
216 ssSetInputPortWidth(childS, 0, 1);
217 }
218
219 /* port 1 */
220 {
221 int8_T const **sfcnUPtrs = (int8_T const **)
222 malloc(1 * sizeof(int8_T *));
223 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
224 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
225 ssGetLocalBlockIO(rts))->DataTypeConversion3_h;
226 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
227 _ssSetInputPortNumDimensions(childS, 1, 1);
228 ssSetInputPortWidth(childS, 1, 1);
229 }
230
231 /* port 2 */
232 {
233 real32_T const **sfcnUPtrs = (real32_T const **)
234 malloc(1 * sizeof(real32_T *));
235 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
236 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
237 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
238 _ssSetInputPortNumDimensions(childS, 2, 1);
239 ssSetInputPortWidth(childS, 2, 1);
240 }
241
242 /* port 3 */
243 {
244 real32_T const **sfcnUPtrs = (real32_T const **)
245 malloc(1 * sizeof(real32_T *));
246 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
247 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
248 ssGetLocalBlockIO(rts))->Switch_k;
249 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
250 _ssSetInputPortNumDimensions(childS, 3, 1);
251 ssSetInputPortWidth(childS, 3, 1);
252 }
253
254 /* port 4 */
255 {
256 real32_T const **sfcnUPtrs = (real32_T const **)
257 malloc(1 * sizeof(real32_T *));
258 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
259 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
260 ssGetLocalBlockIO(rts))->Switch_k;
261 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
262 _ssSetInputPortNumDimensions(childS, 4, 1);
263 ssSetInputPortWidth(childS, 4, 1);
264 }
265
266 /* port 5 */
267 {
268 real32_T const **sfcnUPtrs = (real32_T const **)
269 malloc(1 * sizeof(real32_T *));
270 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
271 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
272 ssGetLocalBlockIO(rts))->Switch4;
273 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
274 _ssSetInputPortNumDimensions(childS, 5, 1);
275 ssSetInputPortWidth(childS, 5, 1);
276 }
277 }
278
279 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
280 RegNumOutputPorts);
281 ssSetRegNumOutputPortsFcnArg(childS,childS);
282
283 /* outputs */
284 {
285 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
286 calloc(1, sizeof(struct _ssPortOutputs));
287 ss_VALIDATE_MEMORY(rts,outputPortInfo);
288 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
289 _ssSetNumOutputPorts(childS, 1);
290
291 /* port 0 */
292 {
293 _ssSetOutputPortNumDimensions(childS, 0, 1);
294 ssSetOutputPortWidth(childS, 0, 1);
295 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
296 ssGetLocalBlockIO(rts))->GeneratedSFunction));
297 }
298 }
299
300 /* path info */
301 _ssSetModelName(childS, "LagFilter_sf");
302 _ssSetPath(childS,
303 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/FixthrustL/ lag filter/Generated S-Function");
304 if (ssGetRTModel(rts) == (NULL)) {
305 _ssSetParentSS(childS, rts);
306 _ssSetRootSS(childS, ssGetRootSS(rts));
307 } else {
308 ssSetRTModel(childS,ssGetRTModel(rts));
309 _ssSetParentSS(childS, (NULL));
310 _ssSetRootSS(childS, childS);
311 }
312
313 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
314
315 /* work vectors */
316 {
317 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
318 (4 * sizeof(struct _ssDWorkRecord));
319 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
320 calloc(4, sizeof(struct _ssDWorkAuxRecord));
321 ss_VALIDATE_MEMORY(rts,dWorkRecord);
322 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
323 ssSetSFcnDWork(childS, dWorkRecord);
324 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
325 _ssSetNumDWork(childS, 4);
326
327 /* DWORK0 */
328 ssSetDWorkWidth(childS, 0, 1);
329 ssSetDWorkDataType(childS, 0,SS_SINGLE);
330 ssSetDWorkComplexSignal(childS, 0, 0);
331 ssSetDWorkUsedAsDState(childS, 0, 1);
332 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 147))[0]);
333
334 /* DWORK1 */
335 ssSetDWorkWidth(childS, 1, 1);
336 ssSetDWorkDataType(childS, 1,SS_SINGLE);
337 ssSetDWorkComplexSignal(childS, 1, 0);
338 ssSetDWorkUsedAsDState(childS, 1, 1);
339 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 148))[0]);
340
341 /* DWORK2 */
342 ssSetDWorkWidth(childS, 2, 1);
343 ssSetDWorkDataType(childS, 2,SS_INT8);
344 ssSetDWorkComplexSignal(childS, 2, 0);
345 ssSetDWorkUsedAsDState(childS, 2, 1);
346 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 374))[0]);
347
348 /* DWORK3 */
349 ssSetDWorkWidth(childS, 3, 1);
350 ssSetDWorkDataType(childS, 3,SS_INT8);
351 ssSetDWorkComplexSignal(childS, 3, 0);
352 ssSetDWorkUsedAsDState(childS, 3, 1);
353 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 375))[0]);
354 }
355
356 (childS)->regDataType.arg1 = ((void *)(childS));
357 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
358 FcnSetErrorStatus);
359 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
360 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
361 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
362 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
363
364 /* registration */
365#if defined(MATLAB_MEX_FILE)
366
367 {
368 int_T i;
369 mxArray *plhs[1];
370 mxArray *prhs[4];
371 double *pr;
372 volatile int_T *intS = (int_T *)&childS;
373 int_T addrlen = sizeof(SimStruct *);
374 int_T m = addrlen/sizeof(int_T) + 1;
375 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
376 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
377 pr = mxGetPr(prhs[1]);
378 for (i = 0; i < m - 1; i++) {
379 pr[i] = (double)intS[i];
380 }
381
382 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
383 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
384 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
385
386 /* Reset port dimensions info functions because the S-function
387 * and accelerator mex-files explicitly set their dimensions,
388 * i.e., they are not dynamically sized. For this case, the
389 * mex-file is responsible for the dimensions info memory
390 * and Simulink should not free it. This is achieved by
391 * setting the following two methods to NULL.
392 */
393 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
394 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
395
396 /*
397 * Setup function pointers and call mdlInitializeSizes via
398 * simulink.c
399 */
400 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
401 mxDestroyArray(plhs[0]);
402 mxDestroyArray(prhs[0]);
403 mxDestroyArray(prhs[1]);
404 mxDestroyArray(prhs[2]);
405 mxDestroyArray(prhs[3]);
406 }
407
408#else
409
410 {
411 LagFilter_sf(childS);
412 sfcnInitializeSizes(childS);
413 }
414
415#endif
416
417 sfcnInitializeSampleTimes(childS);
418
419 /* adjust sample time */
420 ssSetSampleTime(childS, 0, 0.0);
421 ssSetOffsetTime(childS, 0, 0.0);
422 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
423
424 /* set compiled values of dynamic vector attributes */
425 ssSetNumNonsampledZCs(childS, 0);
426
427 /* Update connectivity flags for each port */
428 _ssSetInputPortConnected(childS, 0, 1);
429 _ssSetInputPortConnected(childS, 1, 1);
430 _ssSetInputPortConnected(childS, 2, 1);
431 _ssSetInputPortConnected(childS, 3, 1);
432 _ssSetInputPortConnected(childS, 4, 1);
433 _ssSetInputPortConnected(childS, 5, 1);
434 _ssSetOutputPortConnected(childS, 0, 1);
435 _ssSetOutputPortBeingMerged(childS, 0, 0);
436
437 /* Update the BufferDstPort flags for each input port */
438 _ssSetInputPortBufferDstPort(childS, 0, -1);
439 _ssSetInputPortBufferDstPort(childS, 1, -1);
440 _ssSetInputPortBufferDstPort(childS, 2, -1);
441 _ssSetInputPortBufferDstPort(childS, 3, -1);
442 _ssSetInputPortBufferDstPort(childS, 4, -1);
443 _ssSetInputPortBufferDstPort(childS, 5, -1);
444 }
445
446 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S186>/Generated S-Function (SaturationLimiter_sf) */
447 {
448 SimStruct *childS = ssGetSFunction(rts, 1);
449
450 /* timing info */
451 time_T *sfcnPeriod;
452 time_T *sfcnOffset;
453 int_T *sfcnTsMap;
454 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
455 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
456 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
457 ss_VALIDATE_MEMORY(rts,sfcnOffset);
458 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
459 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
460 (void) memset((void*)sfcnPeriod, 0,
461 sizeof(time_T)*1);
462 (void) memset((void*)sfcnOffset, 0,
463 sizeof(time_T)*1);
464 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
465 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
466 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
467
468 /* Set up the mdlInfo pointer */
469# ifdef USE_RTMODEL
470
471 {
472 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
473 struct _ssBlkInfo2));
474 ss_VALIDATE_MEMORY(rts,blkInfo2);
475 ssSetBlkInfo2Ptr(childS, blkInfo2);
476 }
477
478 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
479
480# else
481
482 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
483
484# endif /* USE_RTMODEL */
485
486 /* Allocate memory of model methods 2 */
487 {
488 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
489 malloc(sizeof(struct _ssSFcnModelMethods2));
490 ss_VALIDATE_MEMORY(rts,methods2);
491 ssSetModelMethods2(childS, methods2);
492 }
493
494 /* Allocate memory of model methods 3 */
495 {
496 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
497 malloc(sizeof(struct _ssSFcnModelMethods3));
498 ss_VALIDATE_MEMORY(rts,methods3);
499 ssSetModelMethods3(childS, methods3);
500 }
501
502 /* Allocate memory for states auxilliary information */
503 {
504 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
505 (sizeof(struct _ssStatesInfo2));
506 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
507 malloc(sizeof(ssPeriodicStatesInfo));
508 ss_VALIDATE_MEMORY(rts,statesInfo2);
509 ssSetStatesInfo2(childS, statesInfo2);
510 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
511 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
512 }
513
514 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
515 RegNumInputPorts);
516 ssSetRegNumInputPortsFcnArg(childS,childS);
517
518 /* inputs */
519 {
520 struct _ssPortInputs *inputPortInfo =
521 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
522 ss_VALIDATE_MEMORY(rts,inputPortInfo);
523 _ssSetNumInputPorts(childS, 3);
524 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
525
526 /* port 0 */
527 {
528 real32_T const **sfcnUPtrs = (real32_T const **)
529 malloc(1 * sizeof(real32_T *));
530 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
531 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
532 ssGetLocalBlockIO(rts))->Sum_hq;
533 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
534 _ssSetInputPortNumDimensions(childS, 0, 1);
535 ssSetInputPortWidth(childS, 0, 1);
536 }
537
538 /* port 1 */
539 {
540 real32_T const **sfcnUPtrs = (real32_T const **)
541 malloc(1 * sizeof(real32_T *));
542 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
543 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;
544 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
545 _ssSetInputPortNumDimensions(childS, 1, 1);
546 ssSetInputPortWidth(childS, 1, 1);
547 }
548
549 /* port 2 */
550 {
551 real32_T const **sfcnUPtrs = (real32_T const **)
552 malloc(1 * sizeof(real32_T *));
553 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
554 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;
555 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
556 _ssSetInputPortNumDimensions(childS, 2, 1);
557 ssSetInputPortWidth(childS, 2, 1);
558 }
559 }
560
561 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
562 RegNumOutputPorts);
563 ssSetRegNumOutputPortsFcnArg(childS,childS);
564
565 /* outputs */
566 {
567 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
568 calloc(1, sizeof(struct _ssPortOutputs));
569 ss_VALIDATE_MEMORY(rts,outputPortInfo);
570 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
571 _ssSetNumOutputPorts(childS, 1);
572
573 /* port 0 */
574 {
575 _ssSetOutputPortNumDimensions(childS, 0, 1);
576 ssSetOutputPortWidth(childS, 0, 1);
577 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
578 ssGetLocalBlockIO(rts))->GeneratedSFunction_c));
579 }
580 }
581
582 /* path info */
583 _ssSetModelName(childS, "SaturationLimiter_sf");
584 _ssSetPath(childS,
585 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/Saturation Limiter1/Generated S-Function");
586 if (ssGetRTModel(rts) == (NULL)) {
587 _ssSetParentSS(childS, rts);
588 _ssSetRootSS(childS, ssGetRootSS(rts));
589 } else {
590 ssSetRTModel(childS,ssGetRTModel(rts));
591 _ssSetParentSS(childS, (NULL));
592 _ssSetRootSS(childS, childS);
593 }
594
595 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
596 (childS)->regDataType.arg1 = ((void *)(childS));
597 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
598 FcnSetErrorStatus);
599 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
600 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
601 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
602 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
603
604 /* registration */
605#if defined(MATLAB_MEX_FILE)
606
607 {
608 int_T i;
609 mxArray *plhs[1];
610 mxArray *prhs[4];
611 double *pr;
612 volatile int_T *intS = (int_T *)&childS;
613 int_T addrlen = sizeof(SimStruct *);
614 int_T m = addrlen/sizeof(int_T) + 1;
615 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
616 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
617 pr = mxGetPr(prhs[1]);
618 for (i = 0; i < m - 1; i++) {
619 pr[i] = (double)intS[i];
620 }
621
622 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
623 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
624 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
625
626 /* Reset port dimensions info functions because the S-function
627 * and accelerator mex-files explicitly set their dimensions,
628 * i.e., they are not dynamically sized. For this case, the
629 * mex-file is responsible for the dimensions info memory
630 * and Simulink should not free it. This is achieved by
631 * setting the following two methods to NULL.
632 */
633 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
634 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
635
636 /*
637 * Setup function pointers and call mdlInitializeSizes via
638 * simulink.c
639 */
640 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
641 mxDestroyArray(plhs[0]);
642 mxDestroyArray(prhs[0]);
643 mxDestroyArray(prhs[1]);
644 mxDestroyArray(prhs[2]);
645 mxDestroyArray(prhs[3]);
646 }
647
648#else
649
650 {
651 SaturationLimiter_sf(childS);
652 sfcnInitializeSizes(childS);
653 }
654
655#endif
656
657 sfcnInitializeSampleTimes(childS);
658
659 /* adjust sample time */
660 ssSetSampleTime(childS, 0, 0.0);
661 ssSetOffsetTime(childS, 0, 0.0);
662 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
663
664 /* set compiled values of dynamic vector attributes */
665 ssSetNumNonsampledZCs(childS, 0);
666
667 /* Update connectivity flags for each port */
668 _ssSetInputPortConnected(childS, 0, 1);
669 _ssSetInputPortConnected(childS, 1, 1);
670 _ssSetInputPortConnected(childS, 2, 1);
671 _ssSetOutputPortConnected(childS, 0, 1);
672 _ssSetOutputPortBeingMerged(childS, 0, 0);
673
674 /* Update the BufferDstPort flags for each input port */
675 _ssSetInputPortBufferDstPort(childS, 0, -1);
676 _ssSetInputPortBufferDstPort(childS, 1, -1);
677 _ssSetInputPortBufferDstPort(childS, 2, -1);
678 }
679
680 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S188>/Generated S-Function (Gain_sf) */
681 {
682 SimStruct *childS = ssGetSFunction(rts, 2);
683
684 /* timing info */
685 time_T *sfcnPeriod;
686 time_T *sfcnOffset;
687 int_T *sfcnTsMap;
688 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
689 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
690 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
691 ss_VALIDATE_MEMORY(rts,sfcnOffset);
692 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
693 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
694 (void) memset((void*)sfcnPeriod, 0,
695 sizeof(time_T)*1);
696 (void) memset((void*)sfcnOffset, 0,
697 sizeof(time_T)*1);
698 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
699 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
700 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
701
702 /* Set up the mdlInfo pointer */
703# ifdef USE_RTMODEL
704
705 {
706 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
707 struct _ssBlkInfo2));
708 ss_VALIDATE_MEMORY(rts,blkInfo2);
709 ssSetBlkInfo2Ptr(childS, blkInfo2);
710 }
711
712 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
713
714# else
715
716 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
717
718# endif /* USE_RTMODEL */
719
720 /* Allocate memory of model methods 2 */
721 {
722 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
723 malloc(sizeof(struct _ssSFcnModelMethods2));
724 ss_VALIDATE_MEMORY(rts,methods2);
725 ssSetModelMethods2(childS, methods2);
726 }
727
728 /* Allocate memory of model methods 3 */
729 {
730 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
731 malloc(sizeof(struct _ssSFcnModelMethods3));
732 ss_VALIDATE_MEMORY(rts,methods3);
733 ssSetModelMethods3(childS, methods3);
734 }
735
736 /* Allocate memory for states auxilliary information */
737 {
738 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
739 (sizeof(struct _ssStatesInfo2));
740 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
741 malloc(sizeof(ssPeriodicStatesInfo));
742 ss_VALIDATE_MEMORY(rts,statesInfo2);
743 ssSetStatesInfo2(childS, statesInfo2);
744 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
745 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
746 }
747
748 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
749 RegNumInputPorts);
750 ssSetRegNumInputPortsFcnArg(childS,childS);
751
752 /* inputs */
753 {
754 struct _ssPortInputs *inputPortInfo =
755 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
756 ss_VALIDATE_MEMORY(rts,inputPortInfo);
757 _ssSetNumInputPorts(childS, 2);
758 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
759
760 /* port 0 */
761 {
762 real32_T const **sfcnUPtrs = (real32_T const **)
763 malloc(1 * sizeof(real32_T *));
764 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
765 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
766 ssGetLocalBlockIO(rts))->GeneratedSFunction_c;
767 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
768 _ssSetInputPortNumDimensions(childS, 0, 1);
769 ssSetInputPortWidth(childS, 0, 1);
770 }
771
772 /* port 1 */
773 {
774 real32_T const **sfcnUPtrs = (real32_T const **)
775 malloc(1 * sizeof(real32_T *));
776 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
777 sfcnUPtrs[0] = (real32_T const *)
778 &AFCS_MODEL1_ConstP.Constant1_Value_i;
779 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
780 _ssSetInputPortNumDimensions(childS, 1, 1);
781 ssSetInputPortWidth(childS, 1, 1);
782 }
783 }
784
785 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
786 RegNumOutputPorts);
787 ssSetRegNumOutputPortsFcnArg(childS,childS);
788
789 /* outputs */
790 {
791 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
792 calloc(1, sizeof(struct _ssPortOutputs));
793 ss_VALIDATE_MEMORY(rts,outputPortInfo);
794 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
795 _ssSetNumOutputPorts(childS, 1);
796
797 /* port 0 */
798 {
799 _ssSetOutputPortNumDimensions(childS, 0, 1);
800 ssSetOutputPortWidth(childS, 0, 1);
801 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
802 ssGetLocalBlockIO(rts))->GeneratedSFunction_c5));
803 }
804 }
805
806 /* path info */
807 _ssSetModelName(childS, "Gain_sf");
808 _ssSetPath(childS,
809 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/gain/Generated S-Function");
810 if (ssGetRTModel(rts) == (NULL)) {
811 _ssSetParentSS(childS, rts);
812 _ssSetRootSS(childS, ssGetRootSS(rts));
813 } else {
814 ssSetRTModel(childS,ssGetRTModel(rts));
815 _ssSetParentSS(childS, (NULL));
816 _ssSetRootSS(childS, childS);
817 }
818
819 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
820 (childS)->regDataType.arg1 = ((void *)(childS));
821 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
822 FcnSetErrorStatus);
823 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
824 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
825 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
826 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
827
828 /* registration */
829#if defined(MATLAB_MEX_FILE)
830
831 {
832 int_T i;
833 mxArray *plhs[1];
834 mxArray *prhs[4];
835 double *pr;
836 volatile int_T *intS = (int_T *)&childS;
837 int_T addrlen = sizeof(SimStruct *);
838 int_T m = addrlen/sizeof(int_T) + 1;
839 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
840 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
841 pr = mxGetPr(prhs[1]);
842 for (i = 0; i < m - 1; i++) {
843 pr[i] = (double)intS[i];
844 }
845
846 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
847 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
848 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
849
850 /* Reset port dimensions info functions because the S-function
851 * and accelerator mex-files explicitly set their dimensions,
852 * i.e., they are not dynamically sized. For this case, the
853 * mex-file is responsible for the dimensions info memory
854 * and Simulink should not free it. This is achieved by
855 * setting the following two methods to NULL.
856 */
857 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
858 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
859
860 /*
861 * Setup function pointers and call mdlInitializeSizes via
862 * simulink.c
863 */
864 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
865 mxDestroyArray(plhs[0]);
866 mxDestroyArray(prhs[0]);
867 mxDestroyArray(prhs[1]);
868 mxDestroyArray(prhs[2]);
869 mxDestroyArray(prhs[3]);
870 }
871
872#else
873
874 {
875 Gain_sf(childS);
876 sfcnInitializeSizes(childS);
877 }
878
879#endif
880
881 sfcnInitializeSampleTimes(childS);
882
883 /* adjust sample time */
884 ssSetSampleTime(childS, 0, 0.0);
885 ssSetOffsetTime(childS, 0, 0.0);
886 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
887
888 /* set compiled values of dynamic vector attributes */
889 ssSetNumNonsampledZCs(childS, 0);
890
891 /* Update connectivity flags for each port */
892 _ssSetInputPortConnected(childS, 0, 1);
893 _ssSetInputPortConnected(childS, 1, 1);
894 _ssSetOutputPortConnected(childS, 0, 1);
895 _ssSetOutputPortBeingMerged(childS, 0, 0);
896
897 /* Update the BufferDstPort flags for each input port */
898 _ssSetInputPortBufferDstPort(childS, 0, -1);
899 _ssSetInputPortBufferDstPort(childS, 1, -1);
900 }
901
902 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S185>/Generated S-Function (LeadLagFilter_sf) */
903 {
904 SimStruct *childS = ssGetSFunction(rts, 3);
905
906 /* timing info */
907 time_T *sfcnPeriod;
908 time_T *sfcnOffset;
909 int_T *sfcnTsMap;
910 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
911 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
912 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
913 ss_VALIDATE_MEMORY(rts,sfcnOffset);
914 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
915 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
916 (void) memset((void*)sfcnPeriod, 0,
917 sizeof(time_T)*1);
918 (void) memset((void*)sfcnOffset, 0,
919 sizeof(time_T)*1);
920 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
921 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
922 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
923
924 /* Set up the mdlInfo pointer */
925# ifdef USE_RTMODEL
926
927 {
928 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
929 struct _ssBlkInfo2));
930 ss_VALIDATE_MEMORY(rts,blkInfo2);
931 ssSetBlkInfo2Ptr(childS, blkInfo2);
932 }
933
934 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
935
936# else
937
938 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
939
940# endif /* USE_RTMODEL */
941
942 /* Allocate memory of model methods 2 */
943 {
944 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
945 malloc(sizeof(struct _ssSFcnModelMethods2));
946 ss_VALIDATE_MEMORY(rts,methods2);
947 ssSetModelMethods2(childS, methods2);
948 }
949
950 /* Allocate memory of model methods 3 */
951 {
952 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
953 malloc(sizeof(struct _ssSFcnModelMethods3));
954 ss_VALIDATE_MEMORY(rts,methods3);
955 ssSetModelMethods3(childS, methods3);
956 }
957
958 /* Allocate memory for states auxilliary information */
959 {
960 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
961 (sizeof(struct _ssStatesInfo2));
962 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
963 malloc(sizeof(ssPeriodicStatesInfo));
964 ss_VALIDATE_MEMORY(rts,statesInfo2);
965 ssSetStatesInfo2(childS, statesInfo2);
966 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
967 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
968 }
969
970 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
971 RegNumInputPorts);
972 ssSetRegNumInputPortsFcnArg(childS,childS);
973
974 /* inputs */
975 {
976 struct _ssPortInputs *inputPortInfo =
977 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
978 ss_VALIDATE_MEMORY(rts,inputPortInfo);
979 _ssSetNumInputPorts(childS, 7);
980 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
981
982 /* port 0 */
983 {
984 real32_T const **sfcnUPtrs = (real32_T const **)
985 malloc(1 * sizeof(real32_T *));
986 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
987 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
988 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
989 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
990 _ssSetInputPortNumDimensions(childS, 0, 1);
991 ssSetInputPortWidth(childS, 0, 1);
992 }
993
994 /* port 1 */
995 {
996 int8_T const **sfcnUPtrs = (int8_T const **)
997 malloc(1 * sizeof(int8_T *));
998 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
999 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
1000 ssGetLocalBlockIO(rts))->DataTypeConversion1_j;
1001 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
1002 _ssSetInputPortNumDimensions(childS, 1, 1);
1003 ssSetInputPortWidth(childS, 1, 1);
1004 }
1005
1006 /* port 2 */
1007 {
1008 real32_T const **sfcnUPtrs = (real32_T const **)
1009 malloc(1 * sizeof(real32_T *));
1010 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1011 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
1012 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
1013 _ssSetInputPortNumDimensions(childS, 2, 1);
1014 ssSetInputPortWidth(childS, 2, 1);
1015 }
1016
1017 /* port 3 */
1018 {
1019 real32_T const **sfcnUPtrs = (real32_T const **)
1020 malloc(1 * sizeof(real32_T *));
1021 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1022 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
1023 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
1024 _ssSetInputPortNumDimensions(childS, 3, 1);
1025 ssSetInputPortWidth(childS, 3, 1);
1026 }
1027
1028 /* port 4 */
1029 {
1030 real32_T const **sfcnUPtrs = (real32_T const **)
1031 malloc(1 * sizeof(real32_T *));
1032 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1033 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1034 ssGetLocalBlockIO(rts))->Switch_k;
1035 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
1036 _ssSetInputPortNumDimensions(childS, 4, 1);
1037 ssSetInputPortWidth(childS, 4, 1);
1038 }
1039
1040 /* port 5 */
1041 {
1042 real32_T const **sfcnUPtrs = (real32_T const **)
1043 malloc(1 * sizeof(real32_T *));
1044 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1045 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1046 ssGetLocalBlockIO(rts))->Switch_k;
1047 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
1048 _ssSetInputPortNumDimensions(childS, 5, 1);
1049 ssSetInputPortWidth(childS, 5, 1);
1050 }
1051
1052 /* port 6 */
1053 {
1054 real32_T const **sfcnUPtrs = (real32_T const **)
1055 malloc(1 * sizeof(real32_T *));
1056 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1057 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1058 ssGetLocalBlockIO(rts))->GeneratedSFunction_c5;
1059 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
1060 _ssSetInputPortNumDimensions(childS, 6, 1);
1061 ssSetInputPortWidth(childS, 6, 1);
1062 }
1063 }
1064
1065 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
1066 RegNumOutputPorts);
1067 ssSetRegNumOutputPortsFcnArg(childS,childS);
1068
1069 /* outputs */
1070 {
1071 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
1072 calloc(1, sizeof(struct _ssPortOutputs));
1073 ss_VALIDATE_MEMORY(rts,outputPortInfo);
1074 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
1075 _ssSetNumOutputPorts(childS, 1);
1076
1077 /* port 0 */
1078 {
1079 _ssSetOutputPortNumDimensions(childS, 0, 1);
1080 ssSetOutputPortWidth(childS, 0, 1);
1081 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
1082 ssGetLocalBlockIO(rts))->GeneratedSFunction_n));
1083 }
1084 }
1085
1086 /* path info */
1087 _ssSetModelName(childS, "LeadLagFilter_sf");
1088 _ssSetPath(childS,
1089 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/Lead lag/Generated S-Function");
1090 if (ssGetRTModel(rts) == (NULL)) {
1091 _ssSetParentSS(childS, rts);
1092 _ssSetRootSS(childS, ssGetRootSS(rts));
1093 } else {
1094 ssSetRTModel(childS,ssGetRTModel(rts));
1095 _ssSetParentSS(childS, (NULL));
1096 _ssSetRootSS(childS, childS);
1097 }
1098
1099 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
1100
1101 /* work vectors */
1102 {
1103 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
1104 (4 * sizeof(struct _ssDWorkRecord));
1105 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
1106 calloc(4, sizeof(struct _ssDWorkAuxRecord));
1107 ss_VALIDATE_MEMORY(rts,dWorkRecord);
1108 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
1109 ssSetSFcnDWork(childS, dWorkRecord);
1110 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
1111 _ssSetNumDWork(childS, 4);
1112
1113 /* DWORK0 */
1114 ssSetDWorkWidth(childS, 0, 1);
1115 ssSetDWorkDataType(childS, 0,SS_SINGLE);
1116 ssSetDWorkComplexSignal(childS, 0, 0);
1117 ssSetDWorkUsedAsDState(childS, 0, 1);
1118 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 149))[0]);
1119
1120 /* DWORK1 */
1121 ssSetDWorkWidth(childS, 1, 1);
1122 ssSetDWorkDataType(childS, 1,SS_SINGLE);
1123 ssSetDWorkComplexSignal(childS, 1, 0);
1124 ssSetDWorkUsedAsDState(childS, 1, 1);
1125 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 150))[0]);
1126
1127 /* DWORK2 */
1128 ssSetDWorkWidth(childS, 2, 1);
1129 ssSetDWorkDataType(childS, 2,SS_INT8);
1130 ssSetDWorkComplexSignal(childS, 2, 0);
1131 ssSetDWorkUsedAsDState(childS, 2, 1);
1132 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 376))[0]);
1133
1134 /* DWORK3 */
1135 ssSetDWorkWidth(childS, 3, 1);
1136 ssSetDWorkDataType(childS, 3,SS_INT8);
1137 ssSetDWorkComplexSignal(childS, 3, 0);
1138 ssSetDWorkUsedAsDState(childS, 3, 1);
1139 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 377))[0]);
1140 }
1141
1142 (childS)->regDataType.arg1 = ((void *)(childS));
1143 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
1144 FcnSetErrorStatus);
1145 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
1146 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
1147 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
1148 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
1149
1150 /* registration */
1151#if defined(MATLAB_MEX_FILE)
1152
1153 {
1154 int_T i;
1155 mxArray *plhs[1];
1156 mxArray *prhs[4];
1157 double *pr;
1158 volatile int_T *intS = (int_T *)&childS;
1159 int_T addrlen = sizeof(SimStruct *);
1160 int_T m = addrlen/sizeof(int_T) + 1;
1161 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
1162 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
1163 pr = mxGetPr(prhs[1]);
1164 for (i = 0; i < m - 1; i++) {
1165 pr[i] = (double)intS[i];
1166 }
1167
1168 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
1169 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
1170 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
1171
1172 /* Reset port dimensions info functions because the S-function
1173 * and accelerator mex-files explicitly set their dimensions,
1174 * i.e., they are not dynamically sized. For this case, the
1175 * mex-file is responsible for the dimensions info memory
1176 * and Simulink should not free it. This is achieved by
1177 * setting the following two methods to NULL.
1178 */
1179 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
1180 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
1181
1182 /*
1183 * Setup function pointers and call mdlInitializeSizes via
1184 * simulink.c
1185 */
1186 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
1187 mxDestroyArray(plhs[0]);
1188 mxDestroyArray(prhs[0]);
1189 mxDestroyArray(prhs[1]);
1190 mxDestroyArray(prhs[2]);
1191 mxDestroyArray(prhs[3]);
1192 }
1193
1194#else
1195
1196 {
1197 LeadLagFilter_sf(childS);
1198 sfcnInitializeSizes(childS);
1199 }
1200
1201#endif
1202
1203 sfcnInitializeSampleTimes(childS);
1204
1205 /* adjust sample time */
1206 ssSetSampleTime(childS, 0, 0.0);
1207 ssSetOffsetTime(childS, 0, 0.0);
1208 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
1209
1210 /* set compiled values of dynamic vector attributes */
1211 ssSetNumNonsampledZCs(childS, 0);
1212
1213 /* Update connectivity flags for each port */
1214 _ssSetInputPortConnected(childS, 0, 1);
1215 _ssSetInputPortConnected(childS, 1, 1);
1216 _ssSetInputPortConnected(childS, 2, 1);
1217 _ssSetInputPortConnected(childS, 3, 1);
1218 _ssSetInputPortConnected(childS, 4, 1);
1219 _ssSetInputPortConnected(childS, 5, 1);
1220 _ssSetInputPortConnected(childS, 6, 1);
1221 _ssSetOutputPortConnected(childS, 0, 1);
1222 _ssSetOutputPortBeingMerged(childS, 0, 0);
1223
1224 /* Update the BufferDstPort flags for each input port */
1225 _ssSetInputPortBufferDstPort(childS, 0, -1);
1226 _ssSetInputPortBufferDstPort(childS, 1, -1);
1227 _ssSetInputPortBufferDstPort(childS, 2, -1);
1228 _ssSetInputPortBufferDstPort(childS, 3, -1);
1229 _ssSetInputPortBufferDstPort(childS, 4, -1);
1230 _ssSetInputPortBufferDstPort(childS, 5, -1);
1231 _ssSetInputPortBufferDstPort(childS, 6, -1);
1232 }
1233
1234 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S187>/Generated S-Function (SaturationLimiter_sf) */
1235 {
1236 SimStruct *childS = ssGetSFunction(rts, 4);
1237
1238 /* timing info */
1239 time_T *sfcnPeriod;
1240 time_T *sfcnOffset;
1241 int_T *sfcnTsMap;
1242 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
1243 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
1244 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
1245 ss_VALIDATE_MEMORY(rts,sfcnOffset);
1246 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
1247 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
1248 (void) memset((void*)sfcnPeriod, 0,
1249 sizeof(time_T)*1);
1250 (void) memset((void*)sfcnOffset, 0,
1251 sizeof(time_T)*1);
1252 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
1253 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
1254 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
1255
1256 /* Set up the mdlInfo pointer */
1257# ifdef USE_RTMODEL
1258
1259 {
1260 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
1261 struct _ssBlkInfo2));
1262 ss_VALIDATE_MEMORY(rts,blkInfo2);
1263 ssSetBlkInfo2Ptr(childS, blkInfo2);
1264 }
1265
1266 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
1267
1268# else
1269
1270 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
1271
1272# endif /* USE_RTMODEL */
1273
1274 /* Allocate memory of model methods 2 */
1275 {
1276 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
1277 malloc(sizeof(struct _ssSFcnModelMethods2));
1278 ss_VALIDATE_MEMORY(rts,methods2);
1279 ssSetModelMethods2(childS, methods2);
1280 }
1281
1282 /* Allocate memory of model methods 3 */
1283 {
1284 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
1285 malloc(sizeof(struct _ssSFcnModelMethods3));
1286 ss_VALIDATE_MEMORY(rts,methods3);
1287 ssSetModelMethods3(childS, methods3);
1288 }
1289
1290 /* Allocate memory for states auxilliary information */
1291 {
1292 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
1293 (sizeof(struct _ssStatesInfo2));
1294 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
1295 malloc(sizeof(ssPeriodicStatesInfo));
1296 ss_VALIDATE_MEMORY(rts,statesInfo2);
1297 ssSetStatesInfo2(childS, statesInfo2);
1298 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
1299 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
1300 }
1301
1302 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
1303 RegNumInputPorts);
1304 ssSetRegNumInputPortsFcnArg(childS,childS);
1305
1306 /* inputs */
1307 {
1308 struct _ssPortInputs *inputPortInfo =
1309 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
1310 ss_VALIDATE_MEMORY(rts,inputPortInfo);
1311 _ssSetNumInputPorts(childS, 3);
1312 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
1313
1314 /* port 0 */
1315 {
1316 real32_T const **sfcnUPtrs = (real32_T const **)
1317 malloc(1 * sizeof(real32_T *));
1318 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1319 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1320 ssGetLocalBlockIO(rts))->GeneratedSFunction_n;
1321 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
1322 _ssSetInputPortNumDimensions(childS, 0, 1);
1323 ssSetInputPortWidth(childS, 0, 1);
1324 }
1325
1326 /* port 1 */
1327 {
1328 real32_T const **sfcnUPtrs = (real32_T const **)
1329 malloc(1 * sizeof(real32_T *));
1330 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1331 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
1332 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
1333 _ssSetInputPortNumDimensions(childS, 1, 1);
1334 ssSetInputPortWidth(childS, 1, 1);
1335 }
1336
1337 /* port 2 */
1338 {
1339 real32_T const **sfcnUPtrs = (real32_T const **)
1340 malloc(1 * sizeof(real32_T *));
1341 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1342 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled110;
1343 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
1344 _ssSetInputPortNumDimensions(childS, 2, 1);
1345 ssSetInputPortWidth(childS, 2, 1);
1346 }
1347 }
1348
1349 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
1350 RegNumOutputPorts);
1351 ssSetRegNumOutputPortsFcnArg(childS,childS);
1352
1353 /* outputs */
1354 {
1355 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
1356 calloc(1, sizeof(struct _ssPortOutputs));
1357 ss_VALIDATE_MEMORY(rts,outputPortInfo);
1358 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
1359 _ssSetNumOutputPorts(childS, 1);
1360
1361 /* port 0 */
1362 {
1363 _ssSetOutputPortNumDimensions(childS, 0, 1);
1364 ssSetOutputPortWidth(childS, 0, 1);
1365 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
1366 ssGetLocalBlockIO(rts))->Product1_g));
1367 }
1368 }
1369
1370 /* path info */
1371 _ssSetModelName(childS, "SaturationLimiter_sf");
1372 _ssSetPath(childS,
1373 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/Saturation Limiter3/Generated S-Function");
1374 if (ssGetRTModel(rts) == (NULL)) {
1375 _ssSetParentSS(childS, rts);
1376 _ssSetRootSS(childS, ssGetRootSS(rts));
1377 } else {
1378 ssSetRTModel(childS,ssGetRTModel(rts));
1379 _ssSetParentSS(childS, (NULL));
1380 _ssSetRootSS(childS, childS);
1381 }
1382
1383 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
1384 (childS)->regDataType.arg1 = ((void *)(childS));
1385 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
1386 FcnSetErrorStatus);
1387 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
1388 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
1389 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
1390 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
1391
1392 /* registration */
1393#if defined(MATLAB_MEX_FILE)
1394
1395 {
1396 int_T i;
1397 mxArray *plhs[1];
1398 mxArray *prhs[4];
1399 double *pr;
1400 volatile int_T *intS = (int_T *)&childS;
1401 int_T addrlen = sizeof(SimStruct *);
1402 int_T m = addrlen/sizeof(int_T) + 1;
1403 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
1404 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
1405 pr = mxGetPr(prhs[1]);
1406 for (i = 0; i < m - 1; i++) {
1407 pr[i] = (double)intS[i];
1408 }
1409
1410 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
1411 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
1412 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
1413
1414 /* Reset port dimensions info functions because the S-function
1415 * and accelerator mex-files explicitly set their dimensions,
1416 * i.e., they are not dynamically sized. For this case, the
1417 * mex-file is responsible for the dimensions info memory
1418 * and Simulink should not free it. This is achieved by
1419 * setting the following two methods to NULL.
1420 */
1421 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
1422 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
1423
1424 /*
1425 * Setup function pointers and call mdlInitializeSizes via
1426 * simulink.c
1427 */
1428 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
1429 mxDestroyArray(plhs[0]);
1430 mxDestroyArray(prhs[0]);
1431 mxDestroyArray(prhs[1]);
1432 mxDestroyArray(prhs[2]);
1433 mxDestroyArray(prhs[3]);
1434 }
1435
1436#else
1437
1438 {
1439 SaturationLimiter_sf(childS);
1440 sfcnInitializeSizes(childS);
1441 }
1442
1443#endif
1444
1445 sfcnInitializeSampleTimes(childS);
1446
1447 /* adjust sample time */
1448 ssSetSampleTime(childS, 0, 0.0);
1449 ssSetOffsetTime(childS, 0, 0.0);
1450 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
1451
1452 /* set compiled values of dynamic vector attributes */
1453 ssSetNumNonsampledZCs(childS, 0);
1454
1455 /* Update connectivity flags for each port */
1456 _ssSetInputPortConnected(childS, 0, 1);
1457 _ssSetInputPortConnected(childS, 1, 1);
1458 _ssSetInputPortConnected(childS, 2, 1);
1459 _ssSetOutputPortConnected(childS, 0, 1);
1460 _ssSetOutputPortBeingMerged(childS, 0, 0);
1461
1462 /* Update the BufferDstPort flags for each input port */
1463 _ssSetInputPortBufferDstPort(childS, 0, -1);
1464 _ssSetInputPortBufferDstPort(childS, 1, -1);
1465 _ssSetInputPortBufferDstPort(childS, 2, -1);
1466 }
1467
1468 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S189>/Generated S-Function (Gain_sf) */
1469 {
1470 SimStruct *childS = ssGetSFunction(rts, 5);
1471
1472 /* timing info */
1473 time_T *sfcnPeriod;
1474 time_T *sfcnOffset;
1475 int_T *sfcnTsMap;
1476 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
1477 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
1478 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
1479 ss_VALIDATE_MEMORY(rts,sfcnOffset);
1480 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
1481 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
1482 (void) memset((void*)sfcnPeriod, 0,
1483 sizeof(time_T)*1);
1484 (void) memset((void*)sfcnOffset, 0,
1485 sizeof(time_T)*1);
1486 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
1487 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
1488 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
1489
1490 /* Set up the mdlInfo pointer */
1491# ifdef USE_RTMODEL
1492
1493 {
1494 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
1495 struct _ssBlkInfo2));
1496 ss_VALIDATE_MEMORY(rts,blkInfo2);
1497 ssSetBlkInfo2Ptr(childS, blkInfo2);
1498 }
1499
1500 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
1501
1502# else
1503
1504 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
1505
1506# endif /* USE_RTMODEL */
1507
1508 /* Allocate memory of model methods 2 */
1509 {
1510 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
1511 malloc(sizeof(struct _ssSFcnModelMethods2));
1512 ss_VALIDATE_MEMORY(rts,methods2);
1513 ssSetModelMethods2(childS, methods2);
1514 }
1515
1516 /* Allocate memory of model methods 3 */
1517 {
1518 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
1519 malloc(sizeof(struct _ssSFcnModelMethods3));
1520 ss_VALIDATE_MEMORY(rts,methods3);
1521 ssSetModelMethods3(childS, methods3);
1522 }
1523
1524 /* Allocate memory for states auxilliary information */
1525 {
1526 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
1527 (sizeof(struct _ssStatesInfo2));
1528 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
1529 malloc(sizeof(ssPeriodicStatesInfo));
1530 ss_VALIDATE_MEMORY(rts,statesInfo2);
1531 ssSetStatesInfo2(childS, statesInfo2);
1532 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
1533 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
1534 }
1535
1536 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
1537 RegNumInputPorts);
1538 ssSetRegNumInputPortsFcnArg(childS,childS);
1539
1540 /* inputs */
1541 {
1542 struct _ssPortInputs *inputPortInfo =
1543 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
1544 ss_VALIDATE_MEMORY(rts,inputPortInfo);
1545 _ssSetNumInputPorts(childS, 2);
1546 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
1547
1548 /* port 0 */
1549 {
1550 real32_T const **sfcnUPtrs = (real32_T const **)
1551 malloc(1 * sizeof(real32_T *));
1552 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1553 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1554 ssGetLocalBlockIO(rts))->GeneratedSFunction_n;
1555 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
1556 _ssSetInputPortNumDimensions(childS, 0, 1);
1557 ssSetInputPortWidth(childS, 0, 1);
1558 }
1559
1560 /* port 1 */
1561 {
1562 real32_T const **sfcnUPtrs = (real32_T const **)
1563 malloc(1 * sizeof(real32_T *));
1564 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1565 sfcnUPtrs[0] = (real32_T const *)
1566 &AFCS_MODEL1_ConstP.Constant2_Value_c;
1567 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
1568 _ssSetInputPortNumDimensions(childS, 1, 1);
1569 ssSetInputPortWidth(childS, 1, 1);
1570 }
1571 }
1572
1573 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
1574 RegNumOutputPorts);
1575 ssSetRegNumOutputPortsFcnArg(childS,childS);
1576
1577 /* outputs */
1578 {
1579 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
1580 calloc(1, sizeof(struct _ssPortOutputs));
1581 ss_VALIDATE_MEMORY(rts,outputPortInfo);
1582 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
1583 _ssSetNumOutputPorts(childS, 1);
1584
1585 /* port 0 */
1586 {
1587 _ssSetOutputPortNumDimensions(childS, 0, 1);
1588 ssSetOutputPortWidth(childS, 0, 1);
1589 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
1590 ssGetLocalBlockIO(rts))->GeneratedSFunction_j));
1591 }
1592 }
1593
1594 /* path info */
1595 _ssSetModelName(childS, "Gain_sf");
1596 _ssSetPath(childS,
1597 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/gain1/Generated S-Function");
1598 if (ssGetRTModel(rts) == (NULL)) {
1599 _ssSetParentSS(childS, rts);
1600 _ssSetRootSS(childS, ssGetRootSS(rts));
1601 } else {
1602 ssSetRTModel(childS,ssGetRTModel(rts));
1603 _ssSetParentSS(childS, (NULL));
1604 _ssSetRootSS(childS, childS);
1605 }
1606
1607 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
1608 (childS)->regDataType.arg1 = ((void *)(childS));
1609 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
1610 FcnSetErrorStatus);
1611 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
1612 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
1613 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
1614 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
1615
1616 /* registration */
1617#if defined(MATLAB_MEX_FILE)
1618
1619 {
1620 int_T i;
1621 mxArray *plhs[1];
1622 mxArray *prhs[4];
1623 double *pr;
1624 volatile int_T *intS = (int_T *)&childS;
1625 int_T addrlen = sizeof(SimStruct *);
1626 int_T m = addrlen/sizeof(int_T) + 1;
1627 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
1628 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
1629 pr = mxGetPr(prhs[1]);
1630 for (i = 0; i < m - 1; i++) {
1631 pr[i] = (double)intS[i];
1632 }
1633
1634 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
1635 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
1636 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
1637
1638 /* Reset port dimensions info functions because the S-function
1639 * and accelerator mex-files explicitly set their dimensions,
1640 * i.e., they are not dynamically sized. For this case, the
1641 * mex-file is responsible for the dimensions info memory
1642 * and Simulink should not free it. This is achieved by
1643 * setting the following two methods to NULL.
1644 */
1645 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
1646 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
1647
1648 /*
1649 * Setup function pointers and call mdlInitializeSizes via
1650 * simulink.c
1651 */
1652 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
1653 mxDestroyArray(plhs[0]);
1654 mxDestroyArray(prhs[0]);
1655 mxDestroyArray(prhs[1]);
1656 mxDestroyArray(prhs[2]);
1657 mxDestroyArray(prhs[3]);
1658 }
1659
1660#else
1661
1662 {
1663 Gain_sf(childS);
1664 sfcnInitializeSizes(childS);
1665 }
1666
1667#endif
1668
1669 sfcnInitializeSampleTimes(childS);
1670
1671 /* adjust sample time */
1672 ssSetSampleTime(childS, 0, 0.0);
1673 ssSetOffsetTime(childS, 0, 0.0);
1674 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
1675
1676 /* set compiled values of dynamic vector attributes */
1677 ssSetNumNonsampledZCs(childS, 0);
1678
1679 /* Update connectivity flags for each port */
1680 _ssSetInputPortConnected(childS, 0, 1);
1681 _ssSetInputPortConnected(childS, 1, 1);
1682 _ssSetOutputPortConnected(childS, 0, 1);
1683 _ssSetOutputPortBeingMerged(childS, 0, 0);
1684
1685 /* Update the BufferDstPort flags for each input port */
1686 _ssSetInputPortBufferDstPort(childS, 0, -1);
1687 _ssSetInputPortBufferDstPort(childS, 1, -1);
1688 }
1689
1690 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S184>/Generated S-Function (IntegratorLimited_sf) */
1691 {
1692 SimStruct *childS = ssGetSFunction(rts, 6);
1693
1694 /* timing info */
1695 time_T *sfcnPeriod;
1696 time_T *sfcnOffset;
1697 int_T *sfcnTsMap;
1698 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
1699 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
1700 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
1701 ss_VALIDATE_MEMORY(rts,sfcnOffset);
1702 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
1703 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
1704 (void) memset((void*)sfcnPeriod, 0,
1705 sizeof(time_T)*1);
1706 (void) memset((void*)sfcnOffset, 0,
1707 sizeof(time_T)*1);
1708 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
1709 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
1710 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
1711
1712 /* Set up the mdlInfo pointer */
1713# ifdef USE_RTMODEL
1714
1715 {
1716 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
1717 struct _ssBlkInfo2));
1718 ss_VALIDATE_MEMORY(rts,blkInfo2);
1719 ssSetBlkInfo2Ptr(childS, blkInfo2);
1720 }
1721
1722 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
1723
1724# else
1725
1726 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
1727
1728# endif /* USE_RTMODEL */
1729
1730 /* Allocate memory of model methods 2 */
1731 {
1732 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
1733 malloc(sizeof(struct _ssSFcnModelMethods2));
1734 ss_VALIDATE_MEMORY(rts,methods2);
1735 ssSetModelMethods2(childS, methods2);
1736 }
1737
1738 /* Allocate memory of model methods 3 */
1739 {
1740 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
1741 malloc(sizeof(struct _ssSFcnModelMethods3));
1742 ss_VALIDATE_MEMORY(rts,methods3);
1743 ssSetModelMethods3(childS, methods3);
1744 }
1745
1746 /* Allocate memory for states auxilliary information */
1747 {
1748 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
1749 (sizeof(struct _ssStatesInfo2));
1750 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
1751 malloc(sizeof(ssPeriodicStatesInfo));
1752 ss_VALIDATE_MEMORY(rts,statesInfo2);
1753 ssSetStatesInfo2(childS, statesInfo2);
1754 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
1755 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
1756 }
1757
1758 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
1759 RegNumInputPorts);
1760 ssSetRegNumInputPortsFcnArg(childS,childS);
1761
1762 /* inputs */
1763 {
1764 struct _ssPortInputs *inputPortInfo =
1765 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
1766 ss_VALIDATE_MEMORY(rts,inputPortInfo);
1767 _ssSetNumInputPorts(childS, 7);
1768 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
1769
1770 /* port 0 */
1771 {
1772 real32_T const **sfcnUPtrs = (real32_T const **)
1773 malloc(1 * sizeof(real32_T *));
1774 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1775 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1776 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
1777 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
1778 _ssSetInputPortNumDimensions(childS, 0, 1);
1779 ssSetInputPortWidth(childS, 0, 1);
1780 }
1781
1782 /* port 1 */
1783 {
1784 int8_T const **sfcnUPtrs = (int8_T const **)
1785 malloc(1 * sizeof(int8_T *));
1786 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1787 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
1788 ssGetLocalBlockIO(rts))->DataTypeConversion1_j;
1789 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
1790 _ssSetInputPortNumDimensions(childS, 1, 1);
1791 ssSetInputPortWidth(childS, 1, 1);
1792 }
1793
1794 /* port 2 */
1795 {
1796 real32_T const **sfcnUPtrs = (real32_T const **)
1797 malloc(1 * sizeof(real32_T *));
1798 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1799 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1800 ssGetLocalBlockIO(rts))->Add2;
1801 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
1802 _ssSetInputPortNumDimensions(childS, 2, 1);
1803 ssSetInputPortWidth(childS, 2, 1);
1804 }
1805
1806 /* port 3 */
1807 {
1808 real32_T const **sfcnUPtrs = (real32_T const **)
1809 malloc(1 * sizeof(real32_T *));
1810 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1811 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1812 ssGetLocalBlockIO(rts))->Add2;
1813 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
1814 _ssSetInputPortNumDimensions(childS, 3, 1);
1815 ssSetInputPortWidth(childS, 3, 1);
1816 }
1817
1818 /* port 4 */
1819 {
1820 real32_T const **sfcnUPtrs = (real32_T const **)
1821 malloc(1 * sizeof(real32_T *));
1822 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1823 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1824 ssGetLocalBlockIO(rts))->Add_g1;
1825 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
1826 _ssSetInputPortNumDimensions(childS, 4, 1);
1827 ssSetInputPortWidth(childS, 4, 1);
1828 }
1829
1830 /* port 5 */
1831 {
1832 real32_T const **sfcnUPtrs = (real32_T const **)
1833 malloc(1 * sizeof(real32_T *));
1834 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1835 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1836 ssGetLocalBlockIO(rts))->Add1;
1837 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
1838 _ssSetInputPortNumDimensions(childS, 5, 1);
1839 ssSetInputPortWidth(childS, 5, 1);
1840 }
1841
1842 /* port 6 */
1843 {
1844 real32_T const **sfcnUPtrs = (real32_T const **)
1845 malloc(1 * sizeof(real32_T *));
1846 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
1847 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
1848 ssGetLocalBlockIO(rts))->GeneratedSFunction_j;
1849 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
1850 _ssSetInputPortNumDimensions(childS, 6, 1);
1851 ssSetInputPortWidth(childS, 6, 1);
1852 }
1853 }
1854
1855 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
1856 RegNumOutputPorts);
1857 ssSetRegNumOutputPortsFcnArg(childS,childS);
1858
1859 /* outputs */
1860 {
1861 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
1862 calloc(1, sizeof(struct _ssPortOutputs));
1863 ss_VALIDATE_MEMORY(rts,outputPortInfo);
1864 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
1865 _ssSetNumOutputPorts(childS, 1);
1866
1867 /* port 0 */
1868 {
1869 _ssSetOutputPortNumDimensions(childS, 0, 1);
1870 ssSetOutputPortWidth(childS, 0, 1);
1871 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
1872 ssGetLocalBlockIO(rts))->Product1_g));
1873 }
1874 }
1875
1876 /* path info */
1877 _ssSetModelName(childS, "IntegratorLimited_sf");
1878 _ssSetPath(childS,
1879 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/Integrator Limited/Generated S-Function");
1880 if (ssGetRTModel(rts) == (NULL)) {
1881 _ssSetParentSS(childS, rts);
1882 _ssSetRootSS(childS, ssGetRootSS(rts));
1883 } else {
1884 ssSetRTModel(childS,ssGetRTModel(rts));
1885 _ssSetParentSS(childS, (NULL));
1886 _ssSetRootSS(childS, childS);
1887 }
1888
1889 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
1890
1891 /* work vectors */
1892 {
1893 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
1894 (4 * sizeof(struct _ssDWorkRecord));
1895 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
1896 calloc(4, sizeof(struct _ssDWorkAuxRecord));
1897 ss_VALIDATE_MEMORY(rts,dWorkRecord);
1898 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
1899 ssSetSFcnDWork(childS, dWorkRecord);
1900 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
1901 _ssSetNumDWork(childS, 4);
1902
1903 /* DWORK0 */
1904 ssSetDWorkWidth(childS, 0, 1);
1905 ssSetDWorkDataType(childS, 0,SS_SINGLE);
1906 ssSetDWorkComplexSignal(childS, 0, 0);
1907 ssSetDWorkUsedAsDState(childS, 0, 1);
1908 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 151))[0]);
1909
1910 /* DWORK1 */
1911 ssSetDWorkWidth(childS, 1, 1);
1912 ssSetDWorkDataType(childS, 1,SS_SINGLE);
1913 ssSetDWorkComplexSignal(childS, 1, 0);
1914 ssSetDWorkUsedAsDState(childS, 1, 1);
1915 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 152))[0]);
1916
1917 /* DWORK2 */
1918 ssSetDWorkWidth(childS, 2, 1);
1919 ssSetDWorkDataType(childS, 2,SS_INT8);
1920 ssSetDWorkComplexSignal(childS, 2, 0);
1921 ssSetDWorkUsedAsDState(childS, 2, 1);
1922 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 378))[0]);
1923
1924 /* DWORK3 */
1925 ssSetDWorkWidth(childS, 3, 1);
1926 ssSetDWorkDataType(childS, 3,SS_INT8);
1927 ssSetDWorkComplexSignal(childS, 3, 0);
1928 ssSetDWorkUsedAsDState(childS, 3, 1);
1929 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 379))[0]);
1930 }
1931
1932 (childS)->regDataType.arg1 = ((void *)(childS));
1933 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
1934 FcnSetErrorStatus);
1935 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
1936 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
1937 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
1938 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
1939
1940 /* registration */
1941#if defined(MATLAB_MEX_FILE)
1942
1943 {
1944 int_T i;
1945 mxArray *plhs[1];
1946 mxArray *prhs[4];
1947 double *pr;
1948 volatile int_T *intS = (int_T *)&childS;
1949 int_T addrlen = sizeof(SimStruct *);
1950 int_T m = addrlen/sizeof(int_T) + 1;
1951 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
1952 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
1953 pr = mxGetPr(prhs[1]);
1954 for (i = 0; i < m - 1; i++) {
1955 pr[i] = (double)intS[i];
1956 }
1957
1958 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
1959 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
1960 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
1961
1962 /* Reset port dimensions info functions because the S-function
1963 * and accelerator mex-files explicitly set their dimensions,
1964 * i.e., they are not dynamically sized. For this case, the
1965 * mex-file is responsible for the dimensions info memory
1966 * and Simulink should not free it. This is achieved by
1967 * setting the following two methods to NULL.
1968 */
1969 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
1970 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
1971
1972 /*
1973 * Setup function pointers and call mdlInitializeSizes via
1974 * simulink.c
1975 */
1976 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
1977 mxDestroyArray(plhs[0]);
1978 mxDestroyArray(prhs[0]);
1979 mxDestroyArray(prhs[1]);
1980 mxDestroyArray(prhs[2]);
1981 mxDestroyArray(prhs[3]);
1982 }
1983
1984#else
1985
1986 {
1987 IntegratorLimited_sf(childS);
1988 sfcnInitializeSizes(childS);
1989 }
1990
1991#endif
1992
1993 sfcnInitializeSampleTimes(childS);
1994
1995 /* adjust sample time */
1996 ssSetSampleTime(childS, 0, 0.0);
1997 ssSetOffsetTime(childS, 0, 0.0);
1998 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
1999
2000 /* set compiled values of dynamic vector attributes */
2001 ssSetNumNonsampledZCs(childS, 0);
2002
2003 /* Update connectivity flags for each port */
2004 _ssSetInputPortConnected(childS, 0, 1);
2005 _ssSetInputPortConnected(childS, 1, 1);
2006 _ssSetInputPortConnected(childS, 2, 1);
2007 _ssSetInputPortConnected(childS, 3, 1);
2008 _ssSetInputPortConnected(childS, 4, 1);
2009 _ssSetInputPortConnected(childS, 5, 1);
2010 _ssSetInputPortConnected(childS, 6, 1);
2011 _ssSetOutputPortConnected(childS, 0, 1);
2012 _ssSetOutputPortBeingMerged(childS, 0, 0);
2013
2014 /* Update the BufferDstPort flags for each input port */
2015 _ssSetInputPortBufferDstPort(childS, 0, -1);
2016 _ssSetInputPortBufferDstPort(childS, 1, -1);
2017 _ssSetInputPortBufferDstPort(childS, 2, -1);
2018 _ssSetInputPortBufferDstPort(childS, 3, -1);
2019 _ssSetInputPortBufferDstPort(childS, 4, -1);
2020 _ssSetInputPortBufferDstPort(childS, 5, -1);
2021 _ssSetInputPortBufferDstPort(childS, 6, -1);
2022 }
2023
2024 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S183>/Generated S-Function (LagFilter_sf) */
2025 {
2026 SimStruct *childS = ssGetSFunction(rts, 7);
2027
2028 /* timing info */
2029 time_T *sfcnPeriod;
2030 time_T *sfcnOffset;
2031 int_T *sfcnTsMap;
2032 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
2033 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
2034 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
2035 ss_VALIDATE_MEMORY(rts,sfcnOffset);
2036 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
2037 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
2038 (void) memset((void*)sfcnPeriod, 0,
2039 sizeof(time_T)*1);
2040 (void) memset((void*)sfcnOffset, 0,
2041 sizeof(time_T)*1);
2042 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
2043 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
2044 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
2045
2046 /* Set up the mdlInfo pointer */
2047# ifdef USE_RTMODEL
2048
2049 {
2050 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
2051 struct _ssBlkInfo2));
2052 ss_VALIDATE_MEMORY(rts,blkInfo2);
2053 ssSetBlkInfo2Ptr(childS, blkInfo2);
2054 }
2055
2056 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
2057
2058# else
2059
2060 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
2061
2062# endif /* USE_RTMODEL */
2063
2064 /* Allocate memory of model methods 2 */
2065 {
2066 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
2067 malloc(sizeof(struct _ssSFcnModelMethods2));
2068 ss_VALIDATE_MEMORY(rts,methods2);
2069 ssSetModelMethods2(childS, methods2);
2070 }
2071
2072 /* Allocate memory of model methods 3 */
2073 {
2074 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
2075 malloc(sizeof(struct _ssSFcnModelMethods3));
2076 ss_VALIDATE_MEMORY(rts,methods3);
2077 ssSetModelMethods3(childS, methods3);
2078 }
2079
2080 /* Allocate memory for states auxilliary information */
2081 {
2082 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
2083 (sizeof(struct _ssStatesInfo2));
2084 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
2085 malloc(sizeof(ssPeriodicStatesInfo));
2086 ss_VALIDATE_MEMORY(rts,statesInfo2);
2087 ssSetStatesInfo2(childS, statesInfo2);
2088 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
2089 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
2090 }
2091
2092 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
2093 RegNumInputPorts);
2094 ssSetRegNumInputPortsFcnArg(childS,childS);
2095
2096 /* inputs */
2097 {
2098 struct _ssPortInputs *inputPortInfo =
2099 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
2100 ss_VALIDATE_MEMORY(rts,inputPortInfo);
2101 _ssSetNumInputPorts(childS, 6);
2102 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
2103
2104 /* port 0 */
2105 {
2106 real32_T const **sfcnUPtrs = (real32_T const **)
2107 malloc(1 * sizeof(real32_T *));
2108 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2109 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2110 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
2111 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
2112 _ssSetInputPortNumDimensions(childS, 0, 1);
2113 ssSetInputPortWidth(childS, 0, 1);
2114 }
2115
2116 /* port 1 */
2117 {
2118 int8_T const **sfcnUPtrs = (int8_T const **)
2119 malloc(1 * sizeof(int8_T *));
2120 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2121 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
2122 ssGetLocalBlockIO(rts))->DataTypeConversion1_j;
2123 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
2124 _ssSetInputPortNumDimensions(childS, 1, 1);
2125 ssSetInputPortWidth(childS, 1, 1);
2126 }
2127
2128 /* port 2 */
2129 {
2130 real32_T const **sfcnUPtrs = (real32_T const **)
2131 malloc(1 * sizeof(real32_T *));
2132 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2133 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
2134 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
2135 _ssSetInputPortNumDimensions(childS, 2, 1);
2136 ssSetInputPortWidth(childS, 2, 1);
2137 }
2138
2139 /* port 3 */
2140 {
2141 real32_T const **sfcnUPtrs = (real32_T const **)
2142 malloc(1 * sizeof(real32_T *));
2143 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2144 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2145 ssGetLocalBlockIO(rts))->Switch_k;
2146 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
2147 _ssSetInputPortNumDimensions(childS, 3, 1);
2148 ssSetInputPortWidth(childS, 3, 1);
2149 }
2150
2151 /* port 4 */
2152 {
2153 real32_T const **sfcnUPtrs = (real32_T const **)
2154 malloc(1 * sizeof(real32_T *));
2155 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2156 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2157 ssGetLocalBlockIO(rts))->Switch_k;
2158 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
2159 _ssSetInputPortNumDimensions(childS, 4, 1);
2160 ssSetInputPortWidth(childS, 4, 1);
2161 }
2162
2163 /* port 5 */
2164 {
2165 real32_T const **sfcnUPtrs = (real32_T const **)
2166 malloc(1 * sizeof(real32_T *));
2167 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2168 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2169 ssGetLocalBlockIO(rts))->Sum1_b;
2170 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
2171 _ssSetInputPortNumDimensions(childS, 5, 1);
2172 ssSetInputPortWidth(childS, 5, 1);
2173 }
2174 }
2175
2176 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
2177 RegNumOutputPorts);
2178 ssSetRegNumOutputPortsFcnArg(childS,childS);
2179
2180 /* outputs */
2181 {
2182 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
2183 calloc(1, sizeof(struct _ssPortOutputs));
2184 ss_VALIDATE_MEMORY(rts,outputPortInfo);
2185 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
2186 _ssSetNumOutputPorts(childS, 1);
2187
2188 /* port 0 */
2189 {
2190 _ssSetOutputPortNumDimensions(childS, 0, 1);
2191 ssSetOutputPortWidth(childS, 0, 1);
2192 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
2193 ssGetLocalBlockIO(rts))->GeneratedSFunction_k));
2194 }
2195 }
2196
2197 /* path info */
2198 _ssSetModelName(childS, "LagFilter_sf");
2199 _ssSetPath(childS,
2200 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VtControl/ lag filter/Generated S-Function");
2201 if (ssGetRTModel(rts) == (NULL)) {
2202 _ssSetParentSS(childS, rts);
2203 _ssSetRootSS(childS, ssGetRootSS(rts));
2204 } else {
2205 ssSetRTModel(childS,ssGetRTModel(rts));
2206 _ssSetParentSS(childS, (NULL));
2207 _ssSetRootSS(childS, childS);
2208 }
2209
2210 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
2211
2212 /* work vectors */
2213 {
2214 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
2215 (4 * sizeof(struct _ssDWorkRecord));
2216 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
2217 calloc(4, sizeof(struct _ssDWorkAuxRecord));
2218 ss_VALIDATE_MEMORY(rts,dWorkRecord);
2219 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
2220 ssSetSFcnDWork(childS, dWorkRecord);
2221 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
2222 _ssSetNumDWork(childS, 4);
2223
2224 /* DWORK0 */
2225 ssSetDWorkWidth(childS, 0, 1);
2226 ssSetDWorkDataType(childS, 0,SS_SINGLE);
2227 ssSetDWorkComplexSignal(childS, 0, 0);
2228 ssSetDWorkUsedAsDState(childS, 0, 1);
2229 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 153))[0]);
2230
2231 /* DWORK1 */
2232 ssSetDWorkWidth(childS, 1, 1);
2233 ssSetDWorkDataType(childS, 1,SS_SINGLE);
2234 ssSetDWorkComplexSignal(childS, 1, 0);
2235 ssSetDWorkUsedAsDState(childS, 1, 1);
2236 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 154))[0]);
2237
2238 /* DWORK2 */
2239 ssSetDWorkWidth(childS, 2, 1);
2240 ssSetDWorkDataType(childS, 2,SS_INT8);
2241 ssSetDWorkComplexSignal(childS, 2, 0);
2242 ssSetDWorkUsedAsDState(childS, 2, 1);
2243 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 380))[0]);
2244
2245 /* DWORK3 */
2246 ssSetDWorkWidth(childS, 3, 1);
2247 ssSetDWorkDataType(childS, 3,SS_INT8);
2248 ssSetDWorkComplexSignal(childS, 3, 0);
2249 ssSetDWorkUsedAsDState(childS, 3, 1);
2250 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 381))[0]);
2251 }
2252
2253 (childS)->regDataType.arg1 = ((void *)(childS));
2254 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
2255 FcnSetErrorStatus);
2256 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
2257 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
2258 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
2259 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
2260
2261 /* registration */
2262#if defined(MATLAB_MEX_FILE)
2263
2264 {
2265 int_T i;
2266 mxArray *plhs[1];
2267 mxArray *prhs[4];
2268 double *pr;
2269 volatile int_T *intS = (int_T *)&childS;
2270 int_T addrlen = sizeof(SimStruct *);
2271 int_T m = addrlen/sizeof(int_T) + 1;
2272 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
2273 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
2274 pr = mxGetPr(prhs[1]);
2275 for (i = 0; i < m - 1; i++) {
2276 pr[i] = (double)intS[i];
2277 }
2278
2279 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
2280 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
2281 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
2282
2283 /* Reset port dimensions info functions because the S-function
2284 * and accelerator mex-files explicitly set their dimensions,
2285 * i.e., they are not dynamically sized. For this case, the
2286 * mex-file is responsible for the dimensions info memory
2287 * and Simulink should not free it. This is achieved by
2288 * setting the following two methods to NULL.
2289 */
2290 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
2291 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
2292
2293 /*
2294 * Setup function pointers and call mdlInitializeSizes via
2295 * simulink.c
2296 */
2297 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
2298 mxDestroyArray(plhs[0]);
2299 mxDestroyArray(prhs[0]);
2300 mxDestroyArray(prhs[1]);
2301 mxDestroyArray(prhs[2]);
2302 mxDestroyArray(prhs[3]);
2303 }
2304
2305#else
2306
2307 {
2308 LagFilter_sf(childS);
2309 sfcnInitializeSizes(childS);
2310 }
2311
2312#endif
2313
2314 sfcnInitializeSampleTimes(childS);
2315
2316 /* adjust sample time */
2317 ssSetSampleTime(childS, 0, 0.0);
2318 ssSetOffsetTime(childS, 0, 0.0);
2319 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
2320
2321 /* set compiled values of dynamic vector attributes */
2322 ssSetNumNonsampledZCs(childS, 0);
2323
2324 /* Update connectivity flags for each port */
2325 _ssSetInputPortConnected(childS, 0, 1);
2326 _ssSetInputPortConnected(childS, 1, 1);
2327 _ssSetInputPortConnected(childS, 2, 1);
2328 _ssSetInputPortConnected(childS, 3, 1);
2329 _ssSetInputPortConnected(childS, 4, 1);
2330 _ssSetInputPortConnected(childS, 5, 1);
2331 _ssSetOutputPortConnected(childS, 0, 1);
2332 _ssSetOutputPortBeingMerged(childS, 0, 0);
2333
2334 /* Update the BufferDstPort flags for each input port */
2335 _ssSetInputPortBufferDstPort(childS, 0, -1);
2336 _ssSetInputPortBufferDstPort(childS, 1, -1);
2337 _ssSetInputPortBufferDstPort(childS, 2, -1);
2338 _ssSetInputPortBufferDstPort(childS, 3, -1);
2339 _ssSetInputPortBufferDstPort(childS, 4, -1);
2340 _ssSetInputPortBufferDstPort(childS, 5, -1);
2341 }
2342
2343 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S179>/Generated S-Function (SaturationLimiter_sf) */
2344 {
2345 SimStruct *childS = ssGetSFunction(rts, 8);
2346
2347 /* timing info */
2348 time_T *sfcnPeriod;
2349 time_T *sfcnOffset;
2350 int_T *sfcnTsMap;
2351 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
2352 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
2353 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
2354 ss_VALIDATE_MEMORY(rts,sfcnOffset);
2355 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
2356 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
2357 (void) memset((void*)sfcnPeriod, 0,
2358 sizeof(time_T)*1);
2359 (void) memset((void*)sfcnOffset, 0,
2360 sizeof(time_T)*1);
2361 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
2362 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
2363 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
2364
2365 /* Set up the mdlInfo pointer */
2366# ifdef USE_RTMODEL
2367
2368 {
2369 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
2370 struct _ssBlkInfo2));
2371 ss_VALIDATE_MEMORY(rts,blkInfo2);
2372 ssSetBlkInfo2Ptr(childS, blkInfo2);
2373 }
2374
2375 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
2376
2377# else
2378
2379 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
2380
2381# endif /* USE_RTMODEL */
2382
2383 /* Allocate memory of model methods 2 */
2384 {
2385 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
2386 malloc(sizeof(struct _ssSFcnModelMethods2));
2387 ss_VALIDATE_MEMORY(rts,methods2);
2388 ssSetModelMethods2(childS, methods2);
2389 }
2390
2391 /* Allocate memory of model methods 3 */
2392 {
2393 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
2394 malloc(sizeof(struct _ssSFcnModelMethods3));
2395 ss_VALIDATE_MEMORY(rts,methods3);
2396 ssSetModelMethods3(childS, methods3);
2397 }
2398
2399 /* Allocate memory for states auxilliary information */
2400 {
2401 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
2402 (sizeof(struct _ssStatesInfo2));
2403 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
2404 malloc(sizeof(ssPeriodicStatesInfo));
2405 ss_VALIDATE_MEMORY(rts,statesInfo2);
2406 ssSetStatesInfo2(childS, statesInfo2);
2407 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
2408 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
2409 }
2410
2411 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
2412 RegNumInputPorts);
2413 ssSetRegNumInputPortsFcnArg(childS,childS);
2414
2415 /* inputs */
2416 {
2417 struct _ssPortInputs *inputPortInfo =
2418 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
2419 ss_VALIDATE_MEMORY(rts,inputPortInfo);
2420 _ssSetNumInputPorts(childS, 3);
2421 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
2422
2423 /* port 0 */
2424 {
2425 real32_T const **sfcnUPtrs = (real32_T const **)
2426 malloc(1 * sizeof(real32_T *));
2427 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2428 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2429 ssGetLocalBlockIO(rts))->Sum_mj;
2430 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
2431 _ssSetInputPortNumDimensions(childS, 0, 1);
2432 ssSetInputPortWidth(childS, 0, 1);
2433 }
2434
2435 /* port 1 */
2436 {
2437 real32_T const **sfcnUPtrs = (real32_T const **)
2438 malloc(1 * sizeof(real32_T *));
2439 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2440 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;
2441 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
2442 _ssSetInputPortNumDimensions(childS, 1, 1);
2443 ssSetInputPortWidth(childS, 1, 1);
2444 }
2445
2446 /* port 2 */
2447 {
2448 real32_T const **sfcnUPtrs = (real32_T const **)
2449 malloc(1 * sizeof(real32_T *));
2450 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2451 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;
2452 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
2453 _ssSetInputPortNumDimensions(childS, 2, 1);
2454 ssSetInputPortWidth(childS, 2, 1);
2455 }
2456 }
2457
2458 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
2459 RegNumOutputPorts);
2460 ssSetRegNumOutputPortsFcnArg(childS,childS);
2461
2462 /* outputs */
2463 {
2464 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
2465 calloc(1, sizeof(struct _ssPortOutputs));
2466 ss_VALIDATE_MEMORY(rts,outputPortInfo);
2467 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
2468 _ssSetNumOutputPorts(childS, 1);
2469
2470 /* port 0 */
2471 {
2472 _ssSetOutputPortNumDimensions(childS, 0, 1);
2473 ssSetOutputPortWidth(childS, 0, 1);
2474 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
2475 ssGetLocalBlockIO(rts))->GeneratedSFunction_g));
2476 }
2477 }
2478
2479 /* path info */
2480 _ssSetModelName(childS, "SaturationLimiter_sf");
2481 _ssSetPath(childS,
2482 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/Saturation Limiter1/Generated S-Function");
2483 if (ssGetRTModel(rts) == (NULL)) {
2484 _ssSetParentSS(childS, rts);
2485 _ssSetRootSS(childS, ssGetRootSS(rts));
2486 } else {
2487 ssSetRTModel(childS,ssGetRTModel(rts));
2488 _ssSetParentSS(childS, (NULL));
2489 _ssSetRootSS(childS, childS);
2490 }
2491
2492 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
2493 (childS)->regDataType.arg1 = ((void *)(childS));
2494 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
2495 FcnSetErrorStatus);
2496 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
2497 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
2498 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
2499 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
2500
2501 /* registration */
2502#if defined(MATLAB_MEX_FILE)
2503
2504 {
2505 int_T i;
2506 mxArray *plhs[1];
2507 mxArray *prhs[4];
2508 double *pr;
2509 volatile int_T *intS = (int_T *)&childS;
2510 int_T addrlen = sizeof(SimStruct *);
2511 int_T m = addrlen/sizeof(int_T) + 1;
2512 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
2513 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
2514 pr = mxGetPr(prhs[1]);
2515 for (i = 0; i < m - 1; i++) {
2516 pr[i] = (double)intS[i];
2517 }
2518
2519 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
2520 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
2521 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
2522
2523 /* Reset port dimensions info functions because the S-function
2524 * and accelerator mex-files explicitly set their dimensions,
2525 * i.e., they are not dynamically sized. For this case, the
2526 * mex-file is responsible for the dimensions info memory
2527 * and Simulink should not free it. This is achieved by
2528 * setting the following two methods to NULL.
2529 */
2530 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
2531 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
2532
2533 /*
2534 * Setup function pointers and call mdlInitializeSizes via
2535 * simulink.c
2536 */
2537 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
2538 mxDestroyArray(plhs[0]);
2539 mxDestroyArray(prhs[0]);
2540 mxDestroyArray(prhs[1]);
2541 mxDestroyArray(prhs[2]);
2542 mxDestroyArray(prhs[3]);
2543 }
2544
2545#else
2546
2547 {
2548 SaturationLimiter_sf(childS);
2549 sfcnInitializeSizes(childS);
2550 }
2551
2552#endif
2553
2554 sfcnInitializeSampleTimes(childS);
2555
2556 /* adjust sample time */
2557 ssSetSampleTime(childS, 0, 0.0);
2558 ssSetOffsetTime(childS, 0, 0.0);
2559 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
2560
2561 /* set compiled values of dynamic vector attributes */
2562 ssSetNumNonsampledZCs(childS, 0);
2563
2564 /* Update connectivity flags for each port */
2565 _ssSetInputPortConnected(childS, 0, 1);
2566 _ssSetInputPortConnected(childS, 1, 1);
2567 _ssSetInputPortConnected(childS, 2, 1);
2568 _ssSetOutputPortConnected(childS, 0, 1);
2569 _ssSetOutputPortBeingMerged(childS, 0, 0);
2570
2571 /* Update the BufferDstPort flags for each input port */
2572 _ssSetInputPortBufferDstPort(childS, 0, -1);
2573 _ssSetInputPortBufferDstPort(childS, 1, -1);
2574 _ssSetInputPortBufferDstPort(childS, 2, -1);
2575 }
2576
2577 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S181>/Generated S-Function (Gain_sf) */
2578 {
2579 SimStruct *childS = ssGetSFunction(rts, 9);
2580
2581 /* timing info */
2582 time_T *sfcnPeriod;
2583 time_T *sfcnOffset;
2584 int_T *sfcnTsMap;
2585 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
2586 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
2587 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
2588 ss_VALIDATE_MEMORY(rts,sfcnOffset);
2589 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
2590 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
2591 (void) memset((void*)sfcnPeriod, 0,
2592 sizeof(time_T)*1);
2593 (void) memset((void*)sfcnOffset, 0,
2594 sizeof(time_T)*1);
2595 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
2596 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
2597 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
2598
2599 /* Set up the mdlInfo pointer */
2600# ifdef USE_RTMODEL
2601
2602 {
2603 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
2604 struct _ssBlkInfo2));
2605 ss_VALIDATE_MEMORY(rts,blkInfo2);
2606 ssSetBlkInfo2Ptr(childS, blkInfo2);
2607 }
2608
2609 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
2610
2611# else
2612
2613 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
2614
2615# endif /* USE_RTMODEL */
2616
2617 /* Allocate memory of model methods 2 */
2618 {
2619 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
2620 malloc(sizeof(struct _ssSFcnModelMethods2));
2621 ss_VALIDATE_MEMORY(rts,methods2);
2622 ssSetModelMethods2(childS, methods2);
2623 }
2624
2625 /* Allocate memory of model methods 3 */
2626 {
2627 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
2628 malloc(sizeof(struct _ssSFcnModelMethods3));
2629 ss_VALIDATE_MEMORY(rts,methods3);
2630 ssSetModelMethods3(childS, methods3);
2631 }
2632
2633 /* Allocate memory for states auxilliary information */
2634 {
2635 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
2636 (sizeof(struct _ssStatesInfo2));
2637 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
2638 malloc(sizeof(ssPeriodicStatesInfo));
2639 ss_VALIDATE_MEMORY(rts,statesInfo2);
2640 ssSetStatesInfo2(childS, statesInfo2);
2641 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
2642 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
2643 }
2644
2645 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
2646 RegNumInputPorts);
2647 ssSetRegNumInputPortsFcnArg(childS,childS);
2648
2649 /* inputs */
2650 {
2651 struct _ssPortInputs *inputPortInfo =
2652 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
2653 ss_VALIDATE_MEMORY(rts,inputPortInfo);
2654 _ssSetNumInputPorts(childS, 2);
2655 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
2656
2657 /* port 0 */
2658 {
2659 real32_T const **sfcnUPtrs = (real32_T const **)
2660 malloc(1 * sizeof(real32_T *));
2661 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2662 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2663 ssGetLocalBlockIO(rts))->GeneratedSFunction_g;
2664 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
2665 _ssSetInputPortNumDimensions(childS, 0, 1);
2666 ssSetInputPortWidth(childS, 0, 1);
2667 }
2668
2669 /* port 1 */
2670 {
2671 real32_T const **sfcnUPtrs = (real32_T const **)
2672 malloc(1 * sizeof(real32_T *));
2673 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2674 sfcnUPtrs[0] = (real32_T const *)
2675 &AFCS_MODEL1_ConstP.Constant1_Value_i;
2676 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
2677 _ssSetInputPortNumDimensions(childS, 1, 1);
2678 ssSetInputPortWidth(childS, 1, 1);
2679 }
2680 }
2681
2682 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
2683 RegNumOutputPorts);
2684 ssSetRegNumOutputPortsFcnArg(childS,childS);
2685
2686 /* outputs */
2687 {
2688 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
2689 calloc(1, sizeof(struct _ssPortOutputs));
2690 ss_VALIDATE_MEMORY(rts,outputPortInfo);
2691 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
2692 _ssSetNumOutputPorts(childS, 1);
2693
2694 /* port 0 */
2695 {
2696 _ssSetOutputPortNumDimensions(childS, 0, 1);
2697 ssSetOutputPortWidth(childS, 0, 1);
2698 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
2699 ssGetLocalBlockIO(rts))->GeneratedSFunction_j5));
2700 }
2701 }
2702
2703 /* path info */
2704 _ssSetModelName(childS, "Gain_sf");
2705 _ssSetPath(childS,
2706 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/gain/Generated S-Function");
2707 if (ssGetRTModel(rts) == (NULL)) {
2708 _ssSetParentSS(childS, rts);
2709 _ssSetRootSS(childS, ssGetRootSS(rts));
2710 } else {
2711 ssSetRTModel(childS,ssGetRTModel(rts));
2712 _ssSetParentSS(childS, (NULL));
2713 _ssSetRootSS(childS, childS);
2714 }
2715
2716 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
2717 (childS)->regDataType.arg1 = ((void *)(childS));
2718 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
2719 FcnSetErrorStatus);
2720 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
2721 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
2722 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
2723 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
2724
2725 /* registration */
2726#if defined(MATLAB_MEX_FILE)
2727
2728 {
2729 int_T i;
2730 mxArray *plhs[1];
2731 mxArray *prhs[4];
2732 double *pr;
2733 volatile int_T *intS = (int_T *)&childS;
2734 int_T addrlen = sizeof(SimStruct *);
2735 int_T m = addrlen/sizeof(int_T) + 1;
2736 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
2737 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
2738 pr = mxGetPr(prhs[1]);
2739 for (i = 0; i < m - 1; i++) {
2740 pr[i] = (double)intS[i];
2741 }
2742
2743 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
2744 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
2745 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
2746
2747 /* Reset port dimensions info functions because the S-function
2748 * and accelerator mex-files explicitly set their dimensions,
2749 * i.e., they are not dynamically sized. For this case, the
2750 * mex-file is responsible for the dimensions info memory
2751 * and Simulink should not free it. This is achieved by
2752 * setting the following two methods to NULL.
2753 */
2754 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
2755 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
2756
2757 /*
2758 * Setup function pointers and call mdlInitializeSizes via
2759 * simulink.c
2760 */
2761 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
2762 mxDestroyArray(plhs[0]);
2763 mxDestroyArray(prhs[0]);
2764 mxDestroyArray(prhs[1]);
2765 mxDestroyArray(prhs[2]);
2766 mxDestroyArray(prhs[3]);
2767 }
2768
2769#else
2770
2771 {
2772 Gain_sf(childS);
2773 sfcnInitializeSizes(childS);
2774 }
2775
2776#endif
2777
2778 sfcnInitializeSampleTimes(childS);
2779
2780 /* adjust sample time */
2781 ssSetSampleTime(childS, 0, 0.0);
2782 ssSetOffsetTime(childS, 0, 0.0);
2783 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
2784
2785 /* set compiled values of dynamic vector attributes */
2786 ssSetNumNonsampledZCs(childS, 0);
2787
2788 /* Update connectivity flags for each port */
2789 _ssSetInputPortConnected(childS, 0, 1);
2790 _ssSetInputPortConnected(childS, 1, 1);
2791 _ssSetOutputPortConnected(childS, 0, 1);
2792 _ssSetOutputPortBeingMerged(childS, 0, 0);
2793
2794 /* Update the BufferDstPort flags for each input port */
2795 _ssSetInputPortBufferDstPort(childS, 0, -1);
2796 _ssSetInputPortBufferDstPort(childS, 1, -1);
2797 }
2798
2799 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S178>/Generated S-Function (LeadLagFilter_sf) */
2800 {
2801 SimStruct *childS = ssGetSFunction(rts, 10);
2802
2803 /* timing info */
2804 time_T *sfcnPeriod;
2805 time_T *sfcnOffset;
2806 int_T *sfcnTsMap;
2807 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
2808 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
2809 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
2810 ss_VALIDATE_MEMORY(rts,sfcnOffset);
2811 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
2812 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
2813 (void) memset((void*)sfcnPeriod, 0,
2814 sizeof(time_T)*1);
2815 (void) memset((void*)sfcnOffset, 0,
2816 sizeof(time_T)*1);
2817 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
2818 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
2819 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
2820
2821 /* Set up the mdlInfo pointer */
2822# ifdef USE_RTMODEL
2823
2824 {
2825 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
2826 struct _ssBlkInfo2));
2827 ss_VALIDATE_MEMORY(rts,blkInfo2);
2828 ssSetBlkInfo2Ptr(childS, blkInfo2);
2829 }
2830
2831 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
2832
2833# else
2834
2835 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
2836
2837# endif /* USE_RTMODEL */
2838
2839 /* Allocate memory of model methods 2 */
2840 {
2841 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
2842 malloc(sizeof(struct _ssSFcnModelMethods2));
2843 ss_VALIDATE_MEMORY(rts,methods2);
2844 ssSetModelMethods2(childS, methods2);
2845 }
2846
2847 /* Allocate memory of model methods 3 */
2848 {
2849 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
2850 malloc(sizeof(struct _ssSFcnModelMethods3));
2851 ss_VALIDATE_MEMORY(rts,methods3);
2852 ssSetModelMethods3(childS, methods3);
2853 }
2854
2855 /* Allocate memory for states auxilliary information */
2856 {
2857 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
2858 (sizeof(struct _ssStatesInfo2));
2859 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
2860 malloc(sizeof(ssPeriodicStatesInfo));
2861 ss_VALIDATE_MEMORY(rts,statesInfo2);
2862 ssSetStatesInfo2(childS, statesInfo2);
2863 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
2864 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
2865 }
2866
2867 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
2868 RegNumInputPorts);
2869 ssSetRegNumInputPortsFcnArg(childS,childS);
2870
2871 /* inputs */
2872 {
2873 struct _ssPortInputs *inputPortInfo =
2874 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
2875 ss_VALIDATE_MEMORY(rts,inputPortInfo);
2876 _ssSetNumInputPorts(childS, 7);
2877 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
2878
2879 /* port 0 */
2880 {
2881 real32_T const **sfcnUPtrs = (real32_T const **)
2882 malloc(1 * sizeof(real32_T *));
2883 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2884 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2885 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
2886 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
2887 _ssSetInputPortNumDimensions(childS, 0, 1);
2888 ssSetInputPortWidth(childS, 0, 1);
2889 }
2890
2891 /* port 1 */
2892 {
2893 int8_T const **sfcnUPtrs = (int8_T const **)
2894 malloc(1 * sizeof(int8_T *));
2895 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2896 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
2897 ssGetLocalBlockIO(rts))->DataTypeConversion2_lt;
2898 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
2899 _ssSetInputPortNumDimensions(childS, 1, 1);
2900 ssSetInputPortWidth(childS, 1, 1);
2901 }
2902
2903 /* port 2 */
2904 {
2905 real32_T const **sfcnUPtrs = (real32_T const **)
2906 malloc(1 * sizeof(real32_T *));
2907 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2908 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
2909 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
2910 _ssSetInputPortNumDimensions(childS, 2, 1);
2911 ssSetInputPortWidth(childS, 2, 1);
2912 }
2913
2914 /* port 3 */
2915 {
2916 real32_T const **sfcnUPtrs = (real32_T const **)
2917 malloc(1 * sizeof(real32_T *));
2918 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2919 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
2920 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
2921 _ssSetInputPortNumDimensions(childS, 3, 1);
2922 ssSetInputPortWidth(childS, 3, 1);
2923 }
2924
2925 /* port 4 */
2926 {
2927 real32_T const **sfcnUPtrs = (real32_T const **)
2928 malloc(1 * sizeof(real32_T *));
2929 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2930 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2931 ssGetLocalBlockIO(rts))->Switch_k;
2932 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
2933 _ssSetInputPortNumDimensions(childS, 4, 1);
2934 ssSetInputPortWidth(childS, 4, 1);
2935 }
2936
2937 /* port 5 */
2938 {
2939 real32_T const **sfcnUPtrs = (real32_T const **)
2940 malloc(1 * sizeof(real32_T *));
2941 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2942 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2943 ssGetLocalBlockIO(rts))->Switch_k;
2944 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
2945 _ssSetInputPortNumDimensions(childS, 5, 1);
2946 ssSetInputPortWidth(childS, 5, 1);
2947 }
2948
2949 /* port 6 */
2950 {
2951 real32_T const **sfcnUPtrs = (real32_T const **)
2952 malloc(1 * sizeof(real32_T *));
2953 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
2954 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
2955 ssGetLocalBlockIO(rts))->GeneratedSFunction_j5;
2956 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
2957 _ssSetInputPortNumDimensions(childS, 6, 1);
2958 ssSetInputPortWidth(childS, 6, 1);
2959 }
2960 }
2961
2962 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
2963 RegNumOutputPorts);
2964 ssSetRegNumOutputPortsFcnArg(childS,childS);
2965
2966 /* outputs */
2967 {
2968 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
2969 calloc(1, sizeof(struct _ssPortOutputs));
2970 ss_VALIDATE_MEMORY(rts,outputPortInfo);
2971 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
2972 _ssSetNumOutputPorts(childS, 1);
2973
2974 /* port 0 */
2975 {
2976 _ssSetOutputPortNumDimensions(childS, 0, 1);
2977 ssSetOutputPortWidth(childS, 0, 1);
2978 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
2979 ssGetLocalBlockIO(rts))->GeneratedSFunction_e));
2980 }
2981 }
2982
2983 /* path info */
2984 _ssSetModelName(childS, "LeadLagFilter_sf");
2985 _ssSetPath(childS,
2986 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/Lead lag/Generated S-Function");
2987 if (ssGetRTModel(rts) == (NULL)) {
2988 _ssSetParentSS(childS, rts);
2989 _ssSetRootSS(childS, ssGetRootSS(rts));
2990 } else {
2991 ssSetRTModel(childS,ssGetRTModel(rts));
2992 _ssSetParentSS(childS, (NULL));
2993 _ssSetRootSS(childS, childS);
2994 }
2995
2996 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
2997
2998 /* work vectors */
2999 {
3000 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
3001 (4 * sizeof(struct _ssDWorkRecord));
3002 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
3003 calloc(4, sizeof(struct _ssDWorkAuxRecord));
3004 ss_VALIDATE_MEMORY(rts,dWorkRecord);
3005 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
3006 ssSetSFcnDWork(childS, dWorkRecord);
3007 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
3008 _ssSetNumDWork(childS, 4);
3009
3010 /* DWORK0 */
3011 ssSetDWorkWidth(childS, 0, 1);
3012 ssSetDWorkDataType(childS, 0,SS_SINGLE);
3013 ssSetDWorkComplexSignal(childS, 0, 0);
3014 ssSetDWorkUsedAsDState(childS, 0, 1);
3015 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 155))[0]);
3016
3017 /* DWORK1 */
3018 ssSetDWorkWidth(childS, 1, 1);
3019 ssSetDWorkDataType(childS, 1,SS_SINGLE);
3020 ssSetDWorkComplexSignal(childS, 1, 0);
3021 ssSetDWorkUsedAsDState(childS, 1, 1);
3022 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 156))[0]);
3023
3024 /* DWORK2 */
3025 ssSetDWorkWidth(childS, 2, 1);
3026 ssSetDWorkDataType(childS, 2,SS_INT8);
3027 ssSetDWorkComplexSignal(childS, 2, 0);
3028 ssSetDWorkUsedAsDState(childS, 2, 1);
3029 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 382))[0]);
3030
3031 /* DWORK3 */
3032 ssSetDWorkWidth(childS, 3, 1);
3033 ssSetDWorkDataType(childS, 3,SS_INT8);
3034 ssSetDWorkComplexSignal(childS, 3, 0);
3035 ssSetDWorkUsedAsDState(childS, 3, 1);
3036 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 383))[0]);
3037 }
3038
3039 (childS)->regDataType.arg1 = ((void *)(childS));
3040 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
3041 FcnSetErrorStatus);
3042 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
3043 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
3044 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
3045 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
3046
3047 /* registration */
3048#if defined(MATLAB_MEX_FILE)
3049
3050 {
3051 int_T i;
3052 mxArray *plhs[1];
3053 mxArray *prhs[4];
3054 double *pr;
3055 volatile int_T *intS = (int_T *)&childS;
3056 int_T addrlen = sizeof(SimStruct *);
3057 int_T m = addrlen/sizeof(int_T) + 1;
3058 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
3059 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
3060 pr = mxGetPr(prhs[1]);
3061 for (i = 0; i < m - 1; i++) {
3062 pr[i] = (double)intS[i];
3063 }
3064
3065 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
3066 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
3067 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
3068
3069 /* Reset port dimensions info functions because the S-function
3070 * and accelerator mex-files explicitly set their dimensions,
3071 * i.e., they are not dynamically sized. For this case, the
3072 * mex-file is responsible for the dimensions info memory
3073 * and Simulink should not free it. This is achieved by
3074 * setting the following two methods to NULL.
3075 */
3076 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
3077 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
3078
3079 /*
3080 * Setup function pointers and call mdlInitializeSizes via
3081 * simulink.c
3082 */
3083 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
3084 mxDestroyArray(plhs[0]);
3085 mxDestroyArray(prhs[0]);
3086 mxDestroyArray(prhs[1]);
3087 mxDestroyArray(prhs[2]);
3088 mxDestroyArray(prhs[3]);
3089 }
3090
3091#else
3092
3093 {
3094 LeadLagFilter_sf(childS);
3095 sfcnInitializeSizes(childS);
3096 }
3097
3098#endif
3099
3100 sfcnInitializeSampleTimes(childS);
3101
3102 /* adjust sample time */
3103 ssSetSampleTime(childS, 0, 0.0);
3104 ssSetOffsetTime(childS, 0, 0.0);
3105 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
3106
3107 /* set compiled values of dynamic vector attributes */
3108 ssSetNumNonsampledZCs(childS, 0);
3109
3110 /* Update connectivity flags for each port */
3111 _ssSetInputPortConnected(childS, 0, 1);
3112 _ssSetInputPortConnected(childS, 1, 1);
3113 _ssSetInputPortConnected(childS, 2, 1);
3114 _ssSetInputPortConnected(childS, 3, 1);
3115 _ssSetInputPortConnected(childS, 4, 1);
3116 _ssSetInputPortConnected(childS, 5, 1);
3117 _ssSetInputPortConnected(childS, 6, 1);
3118 _ssSetOutputPortConnected(childS, 0, 1);
3119 _ssSetOutputPortBeingMerged(childS, 0, 0);
3120
3121 /* Update the BufferDstPort flags for each input port */
3122 _ssSetInputPortBufferDstPort(childS, 0, -1);
3123 _ssSetInputPortBufferDstPort(childS, 1, -1);
3124 _ssSetInputPortBufferDstPort(childS, 2, -1);
3125 _ssSetInputPortBufferDstPort(childS, 3, -1);
3126 _ssSetInputPortBufferDstPort(childS, 4, -1);
3127 _ssSetInputPortBufferDstPort(childS, 5, -1);
3128 _ssSetInputPortBufferDstPort(childS, 6, -1);
3129 }
3130
3131 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S180>/Generated S-Function (SaturationLimiter_sf) */
3132 {
3133 SimStruct *childS = ssGetSFunction(rts, 11);
3134
3135 /* timing info */
3136 time_T *sfcnPeriod;
3137 time_T *sfcnOffset;
3138 int_T *sfcnTsMap;
3139 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
3140 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
3141 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
3142 ss_VALIDATE_MEMORY(rts,sfcnOffset);
3143 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
3144 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
3145 (void) memset((void*)sfcnPeriod, 0,
3146 sizeof(time_T)*1);
3147 (void) memset((void*)sfcnOffset, 0,
3148 sizeof(time_T)*1);
3149 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
3150 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
3151 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
3152
3153 /* Set up the mdlInfo pointer */
3154# ifdef USE_RTMODEL
3155
3156 {
3157 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
3158 struct _ssBlkInfo2));
3159 ss_VALIDATE_MEMORY(rts,blkInfo2);
3160 ssSetBlkInfo2Ptr(childS, blkInfo2);
3161 }
3162
3163 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
3164
3165# else
3166
3167 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
3168
3169# endif /* USE_RTMODEL */
3170
3171 /* Allocate memory of model methods 2 */
3172 {
3173 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
3174 malloc(sizeof(struct _ssSFcnModelMethods2));
3175 ss_VALIDATE_MEMORY(rts,methods2);
3176 ssSetModelMethods2(childS, methods2);
3177 }
3178
3179 /* Allocate memory of model methods 3 */
3180 {
3181 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
3182 malloc(sizeof(struct _ssSFcnModelMethods3));
3183 ss_VALIDATE_MEMORY(rts,methods3);
3184 ssSetModelMethods3(childS, methods3);
3185 }
3186
3187 /* Allocate memory for states auxilliary information */
3188 {
3189 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
3190 (sizeof(struct _ssStatesInfo2));
3191 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
3192 malloc(sizeof(ssPeriodicStatesInfo));
3193 ss_VALIDATE_MEMORY(rts,statesInfo2);
3194 ssSetStatesInfo2(childS, statesInfo2);
3195 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
3196 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
3197 }
3198
3199 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
3200 RegNumInputPorts);
3201 ssSetRegNumInputPortsFcnArg(childS,childS);
3202
3203 /* inputs */
3204 {
3205 struct _ssPortInputs *inputPortInfo =
3206 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
3207 ss_VALIDATE_MEMORY(rts,inputPortInfo);
3208 _ssSetNumInputPorts(childS, 3);
3209 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
3210
3211 /* port 0 */
3212 {
3213 real32_T const **sfcnUPtrs = (real32_T const **)
3214 malloc(1 * sizeof(real32_T *));
3215 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3216 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
3217 ssGetLocalBlockIO(rts))->GeneratedSFunction_e;
3218 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
3219 _ssSetInputPortNumDimensions(childS, 0, 1);
3220 ssSetInputPortWidth(childS, 0, 1);
3221 }
3222
3223 /* port 1 */
3224 {
3225 real32_T const **sfcnUPtrs = (real32_T const **)
3226 malloc(1 * sizeof(real32_T *));
3227 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3228 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
3229 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
3230 _ssSetInputPortNumDimensions(childS, 1, 1);
3231 ssSetInputPortWidth(childS, 1, 1);
3232 }
3233
3234 /* port 2 */
3235 {
3236 real32_T const **sfcnUPtrs = (real32_T const **)
3237 malloc(1 * sizeof(real32_T *));
3238 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3239 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled110;
3240 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
3241 _ssSetInputPortNumDimensions(childS, 2, 1);
3242 ssSetInputPortWidth(childS, 2, 1);
3243 }
3244 }
3245
3246 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
3247 RegNumOutputPorts);
3248 ssSetRegNumOutputPortsFcnArg(childS,childS);
3249
3250 /* outputs */
3251 {
3252 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
3253 calloc(1, sizeof(struct _ssPortOutputs));
3254 ss_VALIDATE_MEMORY(rts,outputPortInfo);
3255 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
3256 _ssSetNumOutputPorts(childS, 1);
3257
3258 /* port 0 */
3259 {
3260 _ssSetOutputPortNumDimensions(childS, 0, 1);
3261 ssSetOutputPortWidth(childS, 0, 1);
3262 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
3263 ssGetLocalBlockIO(rts))->Product1_g));
3264 }
3265 }
3266
3267 /* path info */
3268 _ssSetModelName(childS, "SaturationLimiter_sf");
3269 _ssSetPath(childS,
3270 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/Saturation Limiter3/Generated S-Function");
3271 if (ssGetRTModel(rts) == (NULL)) {
3272 _ssSetParentSS(childS, rts);
3273 _ssSetRootSS(childS, ssGetRootSS(rts));
3274 } else {
3275 ssSetRTModel(childS,ssGetRTModel(rts));
3276 _ssSetParentSS(childS, (NULL));
3277 _ssSetRootSS(childS, childS);
3278 }
3279
3280 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
3281 (childS)->regDataType.arg1 = ((void *)(childS));
3282 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
3283 FcnSetErrorStatus);
3284 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
3285 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
3286 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
3287 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
3288
3289 /* registration */
3290#if defined(MATLAB_MEX_FILE)
3291
3292 {
3293 int_T i;
3294 mxArray *plhs[1];
3295 mxArray *prhs[4];
3296 double *pr;
3297 volatile int_T *intS = (int_T *)&childS;
3298 int_T addrlen = sizeof(SimStruct *);
3299 int_T m = addrlen/sizeof(int_T) + 1;
3300 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
3301 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
3302 pr = mxGetPr(prhs[1]);
3303 for (i = 0; i < m - 1; i++) {
3304 pr[i] = (double)intS[i];
3305 }
3306
3307 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
3308 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
3309 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
3310
3311 /* Reset port dimensions info functions because the S-function
3312 * and accelerator mex-files explicitly set their dimensions,
3313 * i.e., they are not dynamically sized. For this case, the
3314 * mex-file is responsible for the dimensions info memory
3315 * and Simulink should not free it. This is achieved by
3316 * setting the following two methods to NULL.
3317 */
3318 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
3319 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
3320
3321 /*
3322 * Setup function pointers and call mdlInitializeSizes via
3323 * simulink.c
3324 */
3325 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
3326 mxDestroyArray(plhs[0]);
3327 mxDestroyArray(prhs[0]);
3328 mxDestroyArray(prhs[1]);
3329 mxDestroyArray(prhs[2]);
3330 mxDestroyArray(prhs[3]);
3331 }
3332
3333#else
3334
3335 {
3336 SaturationLimiter_sf(childS);
3337 sfcnInitializeSizes(childS);
3338 }
3339
3340#endif
3341
3342 sfcnInitializeSampleTimes(childS);
3343
3344 /* adjust sample time */
3345 ssSetSampleTime(childS, 0, 0.0);
3346 ssSetOffsetTime(childS, 0, 0.0);
3347 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
3348
3349 /* set compiled values of dynamic vector attributes */
3350 ssSetNumNonsampledZCs(childS, 0);
3351
3352 /* Update connectivity flags for each port */
3353 _ssSetInputPortConnected(childS, 0, 1);
3354 _ssSetInputPortConnected(childS, 1, 1);
3355 _ssSetInputPortConnected(childS, 2, 1);
3356 _ssSetOutputPortConnected(childS, 0, 1);
3357 _ssSetOutputPortBeingMerged(childS, 0, 0);
3358
3359 /* Update the BufferDstPort flags for each input port */
3360 _ssSetInputPortBufferDstPort(childS, 0, -1);
3361 _ssSetInputPortBufferDstPort(childS, 1, -1);
3362 _ssSetInputPortBufferDstPort(childS, 2, -1);
3363 }
3364
3365 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S182>/Generated S-Function (Gain_sf) */
3366 {
3367 SimStruct *childS = ssGetSFunction(rts, 12);
3368
3369 /* timing info */
3370 time_T *sfcnPeriod;
3371 time_T *sfcnOffset;
3372 int_T *sfcnTsMap;
3373 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
3374 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
3375 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
3376 ss_VALIDATE_MEMORY(rts,sfcnOffset);
3377 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
3378 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
3379 (void) memset((void*)sfcnPeriod, 0,
3380 sizeof(time_T)*1);
3381 (void) memset((void*)sfcnOffset, 0,
3382 sizeof(time_T)*1);
3383 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
3384 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
3385 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
3386
3387 /* Set up the mdlInfo pointer */
3388# ifdef USE_RTMODEL
3389
3390 {
3391 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
3392 struct _ssBlkInfo2));
3393 ss_VALIDATE_MEMORY(rts,blkInfo2);
3394 ssSetBlkInfo2Ptr(childS, blkInfo2);
3395 }
3396
3397 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
3398
3399# else
3400
3401 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
3402
3403# endif /* USE_RTMODEL */
3404
3405 /* Allocate memory of model methods 2 */
3406 {
3407 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
3408 malloc(sizeof(struct _ssSFcnModelMethods2));
3409 ss_VALIDATE_MEMORY(rts,methods2);
3410 ssSetModelMethods2(childS, methods2);
3411 }
3412
3413 /* Allocate memory of model methods 3 */
3414 {
3415 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
3416 malloc(sizeof(struct _ssSFcnModelMethods3));
3417 ss_VALIDATE_MEMORY(rts,methods3);
3418 ssSetModelMethods3(childS, methods3);
3419 }
3420
3421 /* Allocate memory for states auxilliary information */
3422 {
3423 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
3424 (sizeof(struct _ssStatesInfo2));
3425 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
3426 malloc(sizeof(ssPeriodicStatesInfo));
3427 ss_VALIDATE_MEMORY(rts,statesInfo2);
3428 ssSetStatesInfo2(childS, statesInfo2);
3429 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
3430 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
3431 }
3432
3433 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
3434 RegNumInputPorts);
3435 ssSetRegNumInputPortsFcnArg(childS,childS);
3436
3437 /* inputs */
3438 {
3439 struct _ssPortInputs *inputPortInfo =
3440 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
3441 ss_VALIDATE_MEMORY(rts,inputPortInfo);
3442 _ssSetNumInputPorts(childS, 2);
3443 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
3444
3445 /* port 0 */
3446 {
3447 real32_T const **sfcnUPtrs = (real32_T const **)
3448 malloc(1 * sizeof(real32_T *));
3449 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3450 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
3451 ssGetLocalBlockIO(rts))->GeneratedSFunction_e;
3452 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
3453 _ssSetInputPortNumDimensions(childS, 0, 1);
3454 ssSetInputPortWidth(childS, 0, 1);
3455 }
3456
3457 /* port 1 */
3458 {
3459 real32_T const **sfcnUPtrs = (real32_T const **)
3460 malloc(1 * sizeof(real32_T *));
3461 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3462 sfcnUPtrs[0] = (real32_T const *)
3463 &AFCS_MODEL1_ConstP.Constant2_Value_c;
3464 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
3465 _ssSetInputPortNumDimensions(childS, 1, 1);
3466 ssSetInputPortWidth(childS, 1, 1);
3467 }
3468 }
3469
3470 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
3471 RegNumOutputPorts);
3472 ssSetRegNumOutputPortsFcnArg(childS,childS);
3473
3474 /* outputs */
3475 {
3476 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
3477 calloc(1, sizeof(struct _ssPortOutputs));
3478 ss_VALIDATE_MEMORY(rts,outputPortInfo);
3479 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
3480 _ssSetNumOutputPorts(childS, 1);
3481
3482 /* port 0 */
3483 {
3484 _ssSetOutputPortNumDimensions(childS, 0, 1);
3485 ssSetOutputPortWidth(childS, 0, 1);
3486 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
3487 ssGetLocalBlockIO(rts))->GeneratedSFunction_b));
3488 }
3489 }
3490
3491 /* path info */
3492 _ssSetModelName(childS, "Gain_sf");
3493 _ssSetPath(childS,
3494 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/gain1/Generated S-Function");
3495 if (ssGetRTModel(rts) == (NULL)) {
3496 _ssSetParentSS(childS, rts);
3497 _ssSetRootSS(childS, ssGetRootSS(rts));
3498 } else {
3499 ssSetRTModel(childS,ssGetRTModel(rts));
3500 _ssSetParentSS(childS, (NULL));
3501 _ssSetRootSS(childS, childS);
3502 }
3503
3504 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
3505 (childS)->regDataType.arg1 = ((void *)(childS));
3506 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
3507 FcnSetErrorStatus);
3508 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
3509 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
3510 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
3511 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
3512
3513 /* registration */
3514#if defined(MATLAB_MEX_FILE)
3515
3516 {
3517 int_T i;
3518 mxArray *plhs[1];
3519 mxArray *prhs[4];
3520 double *pr;
3521 volatile int_T *intS = (int_T *)&childS;
3522 int_T addrlen = sizeof(SimStruct *);
3523 int_T m = addrlen/sizeof(int_T) + 1;
3524 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
3525 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
3526 pr = mxGetPr(prhs[1]);
3527 for (i = 0; i < m - 1; i++) {
3528 pr[i] = (double)intS[i];
3529 }
3530
3531 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
3532 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
3533 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
3534
3535 /* Reset port dimensions info functions because the S-function
3536 * and accelerator mex-files explicitly set their dimensions,
3537 * i.e., they are not dynamically sized. For this case, the
3538 * mex-file is responsible for the dimensions info memory
3539 * and Simulink should not free it. This is achieved by
3540 * setting the following two methods to NULL.
3541 */
3542 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
3543 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
3544
3545 /*
3546 * Setup function pointers and call mdlInitializeSizes via
3547 * simulink.c
3548 */
3549 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
3550 mxDestroyArray(plhs[0]);
3551 mxDestroyArray(prhs[0]);
3552 mxDestroyArray(prhs[1]);
3553 mxDestroyArray(prhs[2]);
3554 mxDestroyArray(prhs[3]);
3555 }
3556
3557#else
3558
3559 {
3560 Gain_sf(childS);
3561 sfcnInitializeSizes(childS);
3562 }
3563
3564#endif
3565
3566 sfcnInitializeSampleTimes(childS);
3567
3568 /* adjust sample time */
3569 ssSetSampleTime(childS, 0, 0.0);
3570 ssSetOffsetTime(childS, 0, 0.0);
3571 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
3572
3573 /* set compiled values of dynamic vector attributes */
3574 ssSetNumNonsampledZCs(childS, 0);
3575
3576 /* Update connectivity flags for each port */
3577 _ssSetInputPortConnected(childS, 0, 1);
3578 _ssSetInputPortConnected(childS, 1, 1);
3579 _ssSetOutputPortConnected(childS, 0, 1);
3580 _ssSetOutputPortBeingMerged(childS, 0, 0);
3581
3582 /* Update the BufferDstPort flags for each input port */
3583 _ssSetInputPortBufferDstPort(childS, 0, -1);
3584 _ssSetInputPortBufferDstPort(childS, 1, -1);
3585 }
3586
3587 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S177>/Generated S-Function (IntegratorLimited_sf) */
3588 {
3589 SimStruct *childS = ssGetSFunction(rts, 13);
3590
3591 /* timing info */
3592 time_T *sfcnPeriod;
3593 time_T *sfcnOffset;
3594 int_T *sfcnTsMap;
3595 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
3596 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
3597 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
3598 ss_VALIDATE_MEMORY(rts,sfcnOffset);
3599 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
3600 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
3601 (void) memset((void*)sfcnPeriod, 0,
3602 sizeof(time_T)*1);
3603 (void) memset((void*)sfcnOffset, 0,
3604 sizeof(time_T)*1);
3605 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
3606 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
3607 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
3608
3609 /* Set up the mdlInfo pointer */
3610# ifdef USE_RTMODEL
3611
3612 {
3613 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
3614 struct _ssBlkInfo2));
3615 ss_VALIDATE_MEMORY(rts,blkInfo2);
3616 ssSetBlkInfo2Ptr(childS, blkInfo2);
3617 }
3618
3619 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
3620
3621# else
3622
3623 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
3624
3625# endif /* USE_RTMODEL */
3626
3627 /* Allocate memory of model methods 2 */
3628 {
3629 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
3630 malloc(sizeof(struct _ssSFcnModelMethods2));
3631 ss_VALIDATE_MEMORY(rts,methods2);
3632 ssSetModelMethods2(childS, methods2);
3633 }
3634
3635 /* Allocate memory of model methods 3 */
3636 {
3637 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
3638 malloc(sizeof(struct _ssSFcnModelMethods3));
3639 ss_VALIDATE_MEMORY(rts,methods3);
3640 ssSetModelMethods3(childS, methods3);
3641 }
3642
3643 /* Allocate memory for states auxilliary information */
3644 {
3645 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
3646 (sizeof(struct _ssStatesInfo2));
3647 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
3648 malloc(sizeof(ssPeriodicStatesInfo));
3649 ss_VALIDATE_MEMORY(rts,statesInfo2);
3650 ssSetStatesInfo2(childS, statesInfo2);
3651 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
3652 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
3653 }
3654
3655 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
3656 RegNumInputPorts);
3657 ssSetRegNumInputPortsFcnArg(childS,childS);
3658
3659 /* inputs */
3660 {
3661 struct _ssPortInputs *inputPortInfo =
3662 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
3663 ss_VALIDATE_MEMORY(rts,inputPortInfo);
3664 _ssSetNumInputPorts(childS, 7);
3665 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
3666
3667 /* port 0 */
3668 {
3669 real32_T const **sfcnUPtrs = (real32_T const **)
3670 malloc(1 * sizeof(real32_T *));
3671 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3672 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
3673 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
3674 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
3675 _ssSetInputPortNumDimensions(childS, 0, 1);
3676 ssSetInputPortWidth(childS, 0, 1);
3677 }
3678
3679 /* port 1 */
3680 {
3681 int8_T const **sfcnUPtrs = (int8_T const **)
3682 malloc(1 * sizeof(int8_T *));
3683 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3684 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
3685 ssGetLocalBlockIO(rts))->DataTypeConversion2_lt;
3686 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
3687 _ssSetInputPortNumDimensions(childS, 1, 1);
3688 ssSetInputPortWidth(childS, 1, 1);
3689 }
3690
3691 /* port 2 */
3692 {
3693 real32_T const **sfcnUPtrs = (real32_T const **)
3694 malloc(1 * sizeof(real32_T *));
3695 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3696 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
3697 ssGetLocalBlockIO(rts))->Add2_d;
3698 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
3699 _ssSetInputPortNumDimensions(childS, 2, 1);
3700 ssSetInputPortWidth(childS, 2, 1);
3701 }
3702
3703 /* port 3 */
3704 {
3705 real32_T const **sfcnUPtrs = (real32_T const **)
3706 malloc(1 * sizeof(real32_T *));
3707 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3708 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
3709 ssGetLocalBlockIO(rts))->Add2_d;
3710 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
3711 _ssSetInputPortNumDimensions(childS, 3, 1);
3712 ssSetInputPortWidth(childS, 3, 1);
3713 }
3714
3715 /* port 4 */
3716 {
3717 real32_T const **sfcnUPtrs = (real32_T const **)
3718 malloc(1 * sizeof(real32_T *));
3719 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3720 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
3721 ssGetLocalBlockIO(rts))->Add_l;
3722 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
3723 _ssSetInputPortNumDimensions(childS, 4, 1);
3724 ssSetInputPortWidth(childS, 4, 1);
3725 }
3726
3727 /* port 5 */
3728 {
3729 real32_T const **sfcnUPtrs = (real32_T const **)
3730 malloc(1 * sizeof(real32_T *));
3731 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3732 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
3733 ssGetLocalBlockIO(rts))->Add1_g;
3734 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
3735 _ssSetInputPortNumDimensions(childS, 5, 1);
3736 ssSetInputPortWidth(childS, 5, 1);
3737 }
3738
3739 /* port 6 */
3740 {
3741 real32_T const **sfcnUPtrs = (real32_T const **)
3742 malloc(1 * sizeof(real32_T *));
3743 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
3744 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
3745 ssGetLocalBlockIO(rts))->GeneratedSFunction_b;
3746 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
3747 _ssSetInputPortNumDimensions(childS, 6, 1);
3748 ssSetInputPortWidth(childS, 6, 1);
3749 }
3750 }
3751
3752 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
3753 RegNumOutputPorts);
3754 ssSetRegNumOutputPortsFcnArg(childS,childS);
3755
3756 /* outputs */
3757 {
3758 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
3759 calloc(1, sizeof(struct _ssPortOutputs));
3760 ss_VALIDATE_MEMORY(rts,outputPortInfo);
3761 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
3762 _ssSetNumOutputPorts(childS, 1);
3763
3764 /* port 0 */
3765 {
3766 _ssSetOutputPortNumDimensions(childS, 0, 1);
3767 ssSetOutputPortWidth(childS, 0, 1);
3768 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
3769 ssGetLocalBlockIO(rts))->Product1_g));
3770 }
3771 }
3772
3773 /* path info */
3774 _ssSetModelName(childS, "IntegratorLimited_sf");
3775 _ssSetPath(childS,
3776 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/Integrator Limited/Generated S-Function");
3777 if (ssGetRTModel(rts) == (NULL)) {
3778 _ssSetParentSS(childS, rts);
3779 _ssSetRootSS(childS, ssGetRootSS(rts));
3780 } else {
3781 ssSetRTModel(childS,ssGetRTModel(rts));
3782 _ssSetParentSS(childS, (NULL));
3783 _ssSetRootSS(childS, childS);
3784 }
3785
3786 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
3787
3788 /* work vectors */
3789 {
3790 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
3791 (4 * sizeof(struct _ssDWorkRecord));
3792 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
3793 calloc(4, sizeof(struct _ssDWorkAuxRecord));
3794 ss_VALIDATE_MEMORY(rts,dWorkRecord);
3795 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
3796 ssSetSFcnDWork(childS, dWorkRecord);
3797 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
3798 _ssSetNumDWork(childS, 4);
3799
3800 /* DWORK0 */
3801 ssSetDWorkWidth(childS, 0, 1);
3802 ssSetDWorkDataType(childS, 0,SS_SINGLE);
3803 ssSetDWorkComplexSignal(childS, 0, 0);
3804 ssSetDWorkUsedAsDState(childS, 0, 1);
3805 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 157))[0]);
3806
3807 /* DWORK1 */
3808 ssSetDWorkWidth(childS, 1, 1);
3809 ssSetDWorkDataType(childS, 1,SS_SINGLE);
3810 ssSetDWorkComplexSignal(childS, 1, 0);
3811 ssSetDWorkUsedAsDState(childS, 1, 1);
3812 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 158))[0]);
3813
3814 /* DWORK2 */
3815 ssSetDWorkWidth(childS, 2, 1);
3816 ssSetDWorkDataType(childS, 2,SS_INT8);
3817 ssSetDWorkComplexSignal(childS, 2, 0);
3818 ssSetDWorkUsedAsDState(childS, 2, 1);
3819 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 384))[0]);
3820
3821 /* DWORK3 */
3822 ssSetDWorkWidth(childS, 3, 1);
3823 ssSetDWorkDataType(childS, 3,SS_INT8);
3824 ssSetDWorkComplexSignal(childS, 3, 0);
3825 ssSetDWorkUsedAsDState(childS, 3, 1);
3826 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 385))[0]);
3827 }
3828
3829 (childS)->regDataType.arg1 = ((void *)(childS));
3830 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
3831 FcnSetErrorStatus);
3832 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
3833 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
3834 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
3835 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
3836
3837 /* registration */
3838#if defined(MATLAB_MEX_FILE)
3839
3840 {
3841 int_T i;
3842 mxArray *plhs[1];
3843 mxArray *prhs[4];
3844 double *pr;
3845 volatile int_T *intS = (int_T *)&childS;
3846 int_T addrlen = sizeof(SimStruct *);
3847 int_T m = addrlen/sizeof(int_T) + 1;
3848 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
3849 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
3850 pr = mxGetPr(prhs[1]);
3851 for (i = 0; i < m - 1; i++) {
3852 pr[i] = (double)intS[i];
3853 }
3854
3855 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
3856 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
3857 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
3858
3859 /* Reset port dimensions info functions because the S-function
3860 * and accelerator mex-files explicitly set their dimensions,
3861 * i.e., they are not dynamically sized. For this case, the
3862 * mex-file is responsible for the dimensions info memory
3863 * and Simulink should not free it. This is achieved by
3864 * setting the following two methods to NULL.
3865 */
3866 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
3867 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
3868
3869 /*
3870 * Setup function pointers and call mdlInitializeSizes via
3871 * simulink.c
3872 */
3873 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
3874 mxDestroyArray(plhs[0]);
3875 mxDestroyArray(prhs[0]);
3876 mxDestroyArray(prhs[1]);
3877 mxDestroyArray(prhs[2]);
3878 mxDestroyArray(prhs[3]);
3879 }
3880
3881#else
3882
3883 {
3884 IntegratorLimited_sf(childS);
3885 sfcnInitializeSizes(childS);
3886 }
3887
3888#endif
3889
3890 sfcnInitializeSampleTimes(childS);
3891
3892 /* adjust sample time */
3893 ssSetSampleTime(childS, 0, 0.0);
3894 ssSetOffsetTime(childS, 0, 0.0);
3895 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
3896
3897 /* set compiled values of dynamic vector attributes */
3898 ssSetNumNonsampledZCs(childS, 0);
3899
3900 /* Update connectivity flags for each port */
3901 _ssSetInputPortConnected(childS, 0, 1);
3902 _ssSetInputPortConnected(childS, 1, 1);
3903 _ssSetInputPortConnected(childS, 2, 1);
3904 _ssSetInputPortConnected(childS, 3, 1);
3905 _ssSetInputPortConnected(childS, 4, 1);
3906 _ssSetInputPortConnected(childS, 5, 1);
3907 _ssSetInputPortConnected(childS, 6, 1);
3908 _ssSetOutputPortConnected(childS, 0, 1);
3909 _ssSetOutputPortBeingMerged(childS, 0, 0);
3910
3911 /* Update the BufferDstPort flags for each input port */
3912 _ssSetInputPortBufferDstPort(childS, 0, -1);
3913 _ssSetInputPortBufferDstPort(childS, 1, -1);
3914 _ssSetInputPortBufferDstPort(childS, 2, -1);
3915 _ssSetInputPortBufferDstPort(childS, 3, -1);
3916 _ssSetInputPortBufferDstPort(childS, 4, -1);
3917 _ssSetInputPortBufferDstPort(childS, 5, -1);
3918 _ssSetInputPortBufferDstPort(childS, 6, -1);
3919 }
3920
3921 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S176>/Generated S-Function (LagFilter_sf) */
3922 {
3923 SimStruct *childS = ssGetSFunction(rts, 14);
3924
3925 /* timing info */
3926 time_T *sfcnPeriod;
3927 time_T *sfcnOffset;
3928 int_T *sfcnTsMap;
3929 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
3930 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
3931 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
3932 ss_VALIDATE_MEMORY(rts,sfcnOffset);
3933 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
3934 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
3935 (void) memset((void*)sfcnPeriod, 0,
3936 sizeof(time_T)*1);
3937 (void) memset((void*)sfcnOffset, 0,
3938 sizeof(time_T)*1);
3939 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
3940 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
3941 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
3942
3943 /* Set up the mdlInfo pointer */
3944# ifdef USE_RTMODEL
3945
3946 {
3947 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
3948 struct _ssBlkInfo2));
3949 ss_VALIDATE_MEMORY(rts,blkInfo2);
3950 ssSetBlkInfo2Ptr(childS, blkInfo2);
3951 }
3952
3953 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
3954
3955# else
3956
3957 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
3958
3959# endif /* USE_RTMODEL */
3960
3961 /* Allocate memory of model methods 2 */
3962 {
3963 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
3964 malloc(sizeof(struct _ssSFcnModelMethods2));
3965 ss_VALIDATE_MEMORY(rts,methods2);
3966 ssSetModelMethods2(childS, methods2);
3967 }
3968
3969 /* Allocate memory of model methods 3 */
3970 {
3971 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
3972 malloc(sizeof(struct _ssSFcnModelMethods3));
3973 ss_VALIDATE_MEMORY(rts,methods3);
3974 ssSetModelMethods3(childS, methods3);
3975 }
3976
3977 /* Allocate memory for states auxilliary information */
3978 {
3979 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
3980 (sizeof(struct _ssStatesInfo2));
3981 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
3982 malloc(sizeof(ssPeriodicStatesInfo));
3983 ss_VALIDATE_MEMORY(rts,statesInfo2);
3984 ssSetStatesInfo2(childS, statesInfo2);
3985 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
3986 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
3987 }
3988
3989 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
3990 RegNumInputPorts);
3991 ssSetRegNumInputPortsFcnArg(childS,childS);
3992
3993 /* inputs */
3994 {
3995 struct _ssPortInputs *inputPortInfo =
3996 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
3997 ss_VALIDATE_MEMORY(rts,inputPortInfo);
3998 _ssSetNumInputPorts(childS, 6);
3999 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
4000
4001 /* port 0 */
4002 {
4003 real32_T const **sfcnUPtrs = (real32_T const **)
4004 malloc(1 * sizeof(real32_T *));
4005 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4006 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
4007 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
4008 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
4009 _ssSetInputPortNumDimensions(childS, 0, 1);
4010 ssSetInputPortWidth(childS, 0, 1);
4011 }
4012
4013 /* port 1 */
4014 {
4015 int8_T const **sfcnUPtrs = (int8_T const **)
4016 malloc(1 * sizeof(int8_T *));
4017 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4018 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
4019 ssGetLocalBlockIO(rts))->DataTypeConversion2_lt;
4020 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
4021 _ssSetInputPortNumDimensions(childS, 1, 1);
4022 ssSetInputPortWidth(childS, 1, 1);
4023 }
4024
4025 /* port 2 */
4026 {
4027 real32_T const **sfcnUPtrs = (real32_T const **)
4028 malloc(1 * sizeof(real32_T *));
4029 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4030 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
4031 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
4032 _ssSetInputPortNumDimensions(childS, 2, 1);
4033 ssSetInputPortWidth(childS, 2, 1);
4034 }
4035
4036 /* port 3 */
4037 {
4038 real32_T const **sfcnUPtrs = (real32_T const **)
4039 malloc(1 * sizeof(real32_T *));
4040 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4041 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
4042 ssGetLocalBlockIO(rts))->Switch_k;
4043 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
4044 _ssSetInputPortNumDimensions(childS, 3, 1);
4045 ssSetInputPortWidth(childS, 3, 1);
4046 }
4047
4048 /* port 4 */
4049 {
4050 real32_T const **sfcnUPtrs = (real32_T const **)
4051 malloc(1 * sizeof(real32_T *));
4052 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4053 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
4054 ssGetLocalBlockIO(rts))->Switch_k;
4055 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
4056 _ssSetInputPortNumDimensions(childS, 4, 1);
4057 ssSetInputPortWidth(childS, 4, 1);
4058 }
4059
4060 /* port 5 */
4061 {
4062 real32_T const **sfcnUPtrs = (real32_T const **)
4063 malloc(1 * sizeof(real32_T *));
4064 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4065 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
4066 ssGetLocalBlockIO(rts))->Sum1_a;
4067 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
4068 _ssSetInputPortNumDimensions(childS, 5, 1);
4069 ssSetInputPortWidth(childS, 5, 1);
4070 }
4071 }
4072
4073 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
4074 RegNumOutputPorts);
4075 ssSetRegNumOutputPortsFcnArg(childS,childS);
4076
4077 /* outputs */
4078 {
4079 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
4080 calloc(1, sizeof(struct _ssPortOutputs));
4081 ss_VALIDATE_MEMORY(rts,outputPortInfo);
4082 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
4083 _ssSetNumOutputPorts(childS, 1);
4084
4085 /* port 0 */
4086 {
4087 _ssSetOutputPortNumDimensions(childS, 0, 1);
4088 ssSetOutputPortWidth(childS, 0, 1);
4089 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
4090 ssGetLocalBlockIO(rts))->GeneratedSFunction_m));
4091 }
4092 }
4093
4094 /* path info */
4095 _ssSetModelName(childS, "LagFilter_sf");
4096 _ssSetPath(childS,
4097 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apthrustLcontrol/VcControl/ lag filter/Generated S-Function");
4098 if (ssGetRTModel(rts) == (NULL)) {
4099 _ssSetParentSS(childS, rts);
4100 _ssSetRootSS(childS, ssGetRootSS(rts));
4101 } else {
4102 ssSetRTModel(childS,ssGetRTModel(rts));
4103 _ssSetParentSS(childS, (NULL));
4104 _ssSetRootSS(childS, childS);
4105 }
4106
4107 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
4108
4109 /* work vectors */
4110 {
4111 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
4112 (4 * sizeof(struct _ssDWorkRecord));
4113 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
4114 calloc(4, sizeof(struct _ssDWorkAuxRecord));
4115 ss_VALIDATE_MEMORY(rts,dWorkRecord);
4116 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
4117 ssSetSFcnDWork(childS, dWorkRecord);
4118 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
4119 _ssSetNumDWork(childS, 4);
4120
4121 /* DWORK0 */
4122 ssSetDWorkWidth(childS, 0, 1);
4123 ssSetDWorkDataType(childS, 0,SS_SINGLE);
4124 ssSetDWorkComplexSignal(childS, 0, 0);
4125 ssSetDWorkUsedAsDState(childS, 0, 1);
4126 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 159))[0]);
4127
4128 /* DWORK1 */
4129 ssSetDWorkWidth(childS, 1, 1);
4130 ssSetDWorkDataType(childS, 1,SS_SINGLE);
4131 ssSetDWorkComplexSignal(childS, 1, 0);
4132 ssSetDWorkUsedAsDState(childS, 1, 1);
4133 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 160))[0]);
4134
4135 /* DWORK2 */
4136 ssSetDWorkWidth(childS, 2, 1);
4137 ssSetDWorkDataType(childS, 2,SS_INT8);
4138 ssSetDWorkComplexSignal(childS, 2, 0);
4139 ssSetDWorkUsedAsDState(childS, 2, 1);
4140 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 386))[0]);
4141
4142 /* DWORK3 */
4143 ssSetDWorkWidth(childS, 3, 1);
4144 ssSetDWorkDataType(childS, 3,SS_INT8);
4145 ssSetDWorkComplexSignal(childS, 3, 0);
4146 ssSetDWorkUsedAsDState(childS, 3, 1);
4147 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 387))[0]);
4148 }
4149
4150 (childS)->regDataType.arg1 = ((void *)(childS));
4151 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
4152 FcnSetErrorStatus);
4153 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
4154 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
4155 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
4156 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
4157
4158 /* registration */
4159#if defined(MATLAB_MEX_FILE)
4160
4161 {
4162 int_T i;
4163 mxArray *plhs[1];
4164 mxArray *prhs[4];
4165 double *pr;
4166 volatile int_T *intS = (int_T *)&childS;
4167 int_T addrlen = sizeof(SimStruct *);
4168 int_T m = addrlen/sizeof(int_T) + 1;
4169 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
4170 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
4171 pr = mxGetPr(prhs[1]);
4172 for (i = 0; i < m - 1; i++) {
4173 pr[i] = (double)intS[i];
4174 }
4175
4176 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
4177 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
4178 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
4179
4180 /* Reset port dimensions info functions because the S-function
4181 * and accelerator mex-files explicitly set their dimensions,
4182 * i.e., they are not dynamically sized. For this case, the
4183 * mex-file is responsible for the dimensions info memory
4184 * and Simulink should not free it. This is achieved by
4185 * setting the following two methods to NULL.
4186 */
4187 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
4188 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
4189
4190 /*
4191 * Setup function pointers and call mdlInitializeSizes via
4192 * simulink.c
4193 */
4194 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
4195 mxDestroyArray(plhs[0]);
4196 mxDestroyArray(prhs[0]);
4197 mxDestroyArray(prhs[1]);
4198 mxDestroyArray(prhs[2]);
4199 mxDestroyArray(prhs[3]);
4200 }
4201
4202#else
4203
4204 {
4205 LagFilter_sf(childS);
4206 sfcnInitializeSizes(childS);
4207 }
4208
4209#endif
4210
4211 sfcnInitializeSampleTimes(childS);
4212
4213 /* adjust sample time */
4214 ssSetSampleTime(childS, 0, 0.0);
4215 ssSetOffsetTime(childS, 0, 0.0);
4216 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
4217
4218 /* set compiled values of dynamic vector attributes */
4219 ssSetNumNonsampledZCs(childS, 0);
4220
4221 /* Update connectivity flags for each port */
4222 _ssSetInputPortConnected(childS, 0, 1);
4223 _ssSetInputPortConnected(childS, 1, 1);
4224 _ssSetInputPortConnected(childS, 2, 1);
4225 _ssSetInputPortConnected(childS, 3, 1);
4226 _ssSetInputPortConnected(childS, 4, 1);
4227 _ssSetInputPortConnected(childS, 5, 1);
4228 _ssSetOutputPortConnected(childS, 0, 1);
4229 _ssSetOutputPortBeingMerged(childS, 0, 0);
4230
4231 /* Update the BufferDstPort flags for each input port */
4232 _ssSetInputPortBufferDstPort(childS, 0, -1);
4233 _ssSetInputPortBufferDstPort(childS, 1, -1);
4234 _ssSetInputPortBufferDstPort(childS, 2, -1);
4235 _ssSetInputPortBufferDstPort(childS, 3, -1);
4236 _ssSetInputPortBufferDstPort(childS, 4, -1);
4237 _ssSetInputPortBufferDstPort(childS, 5, -1);
4238 }
4239
4240 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S92>/Generated S-Function1 (SaturationLimiter_sf) */
4241 {
4242 SimStruct *childS = ssGetSFunction(rts, 15);
4243
4244 /* timing info */
4245 time_T *sfcnPeriod;
4246 time_T *sfcnOffset;
4247 int_T *sfcnTsMap;
4248 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
4249 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
4250 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
4251 ss_VALIDATE_MEMORY(rts,sfcnOffset);
4252 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
4253 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
4254 (void) memset((void*)sfcnPeriod, 0,
4255 sizeof(time_T)*1);
4256 (void) memset((void*)sfcnOffset, 0,
4257 sizeof(time_T)*1);
4258 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
4259 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
4260 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
4261
4262 /* Set up the mdlInfo pointer */
4263# ifdef USE_RTMODEL
4264
4265 {
4266 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
4267 struct _ssBlkInfo2));
4268 ss_VALIDATE_MEMORY(rts,blkInfo2);
4269 ssSetBlkInfo2Ptr(childS, blkInfo2);
4270 }
4271
4272 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
4273
4274# else
4275
4276 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
4277
4278# endif /* USE_RTMODEL */
4279
4280 /* Allocate memory of model methods 2 */
4281 {
4282 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
4283 malloc(sizeof(struct _ssSFcnModelMethods2));
4284 ss_VALIDATE_MEMORY(rts,methods2);
4285 ssSetModelMethods2(childS, methods2);
4286 }
4287
4288 /* Allocate memory of model methods 3 */
4289 {
4290 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
4291 malloc(sizeof(struct _ssSFcnModelMethods3));
4292 ss_VALIDATE_MEMORY(rts,methods3);
4293 ssSetModelMethods3(childS, methods3);
4294 }
4295
4296 /* Allocate memory for states auxilliary information */
4297 {
4298 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
4299 (sizeof(struct _ssStatesInfo2));
4300 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
4301 malloc(sizeof(ssPeriodicStatesInfo));
4302 ss_VALIDATE_MEMORY(rts,statesInfo2);
4303 ssSetStatesInfo2(childS, statesInfo2);
4304 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
4305 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
4306 }
4307
4308 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
4309 RegNumInputPorts);
4310 ssSetRegNumInputPortsFcnArg(childS,childS);
4311
4312 /* inputs */
4313 {
4314 struct _ssPortInputs *inputPortInfo =
4315 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
4316 ss_VALIDATE_MEMORY(rts,inputPortInfo);
4317 _ssSetNumInputPorts(childS, 3);
4318 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
4319
4320 /* port 0 */
4321 {
4322 real32_T const **sfcnUPtrs = (real32_T const **)
4323 malloc(1 * sizeof(real32_T *));
4324 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4325 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
4326 ssGetLocalBlockIO(rts))->Sum6;
4327 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
4328 _ssSetInputPortNumDimensions(childS, 0, 1);
4329 ssSetInputPortWidth(childS, 0, 1);
4330 }
4331
4332 /* port 1 */
4333 {
4334 real32_T const **sfcnUPtrs = (real32_T const **)
4335 malloc(1 * sizeof(real32_T *));
4336 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4337 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
4338 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
4339 _ssSetInputPortNumDimensions(childS, 1, 1);
4340 ssSetInputPortWidth(childS, 1, 1);
4341 }
4342
4343 /* port 2 */
4344 {
4345 real32_T const **sfcnUPtrs = (real32_T const **)
4346 malloc(1 * sizeof(real32_T *));
4347 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4348 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;
4349 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
4350 _ssSetInputPortNumDimensions(childS, 2, 1);
4351 ssSetInputPortWidth(childS, 2, 1);
4352 }
4353 }
4354
4355 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
4356 RegNumOutputPorts);
4357 ssSetRegNumOutputPortsFcnArg(childS,childS);
4358
4359 /* outputs */
4360 {
4361 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
4362 calloc(1, sizeof(struct _ssPortOutputs));
4363 ss_VALIDATE_MEMORY(rts,outputPortInfo);
4364 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
4365 _ssSetNumOutputPorts(childS, 1);
4366
4367 /* port 0 */
4368 {
4369 _ssSetOutputPortNumDimensions(childS, 0, 1);
4370 ssSetOutputPortWidth(childS, 0, 1);
4371 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
4372 ssGetLocalBlockIO(rts))->GeneratedSFunction1));
4373 }
4374 }
4375
4376 /* path info */
4377 _ssSetModelName(childS, "SaturationLimiter_sf");
4378 _ssSetPath(childS,
4379 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Saturation Limiter2/Generated S-Function1");
4380 if (ssGetRTModel(rts) == (NULL)) {
4381 _ssSetParentSS(childS, rts);
4382 _ssSetRootSS(childS, ssGetRootSS(rts));
4383 } else {
4384 ssSetRTModel(childS,ssGetRTModel(rts));
4385 _ssSetParentSS(childS, (NULL));
4386 _ssSetRootSS(childS, childS);
4387 }
4388
4389 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
4390 (childS)->regDataType.arg1 = ((void *)(childS));
4391 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
4392 FcnSetErrorStatus);
4393 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
4394 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
4395 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
4396 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
4397
4398 /* registration */
4399#if defined(MATLAB_MEX_FILE)
4400
4401 {
4402 int_T i;
4403 mxArray *plhs[1];
4404 mxArray *prhs[4];
4405 double *pr;
4406 volatile int_T *intS = (int_T *)&childS;
4407 int_T addrlen = sizeof(SimStruct *);
4408 int_T m = addrlen/sizeof(int_T) + 1;
4409 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
4410 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
4411 pr = mxGetPr(prhs[1]);
4412 for (i = 0; i < m - 1; i++) {
4413 pr[i] = (double)intS[i];
4414 }
4415
4416 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
4417 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
4418 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
4419
4420 /* Reset port dimensions info functions because the S-function
4421 * and accelerator mex-files explicitly set their dimensions,
4422 * i.e., they are not dynamically sized. For this case, the
4423 * mex-file is responsible for the dimensions info memory
4424 * and Simulink should not free it. This is achieved by
4425 * setting the following two methods to NULL.
4426 */
4427 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
4428 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
4429
4430 /*
4431 * Setup function pointers and call mdlInitializeSizes via
4432 * simulink.c
4433 */
4434 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
4435 mxDestroyArray(plhs[0]);
4436 mxDestroyArray(prhs[0]);
4437 mxDestroyArray(prhs[1]);
4438 mxDestroyArray(prhs[2]);
4439 mxDestroyArray(prhs[3]);
4440 }
4441
4442#else
4443
4444 {
4445 SaturationLimiter_sf(childS);
4446 sfcnInitializeSizes(childS);
4447 }
4448
4449#endif
4450
4451 sfcnInitializeSampleTimes(childS);
4452
4453 /* adjust sample time */
4454 ssSetSampleTime(childS, 0, 0.0);
4455 ssSetOffsetTime(childS, 0, 0.0);
4456 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
4457
4458 /* set compiled values of dynamic vector attributes */
4459 ssSetNumNonsampledZCs(childS, 0);
4460
4461 /* Update connectivity flags for each port */
4462 _ssSetInputPortConnected(childS, 0, 1);
4463 _ssSetInputPortConnected(childS, 1, 1);
4464 _ssSetInputPortConnected(childS, 2, 1);
4465 _ssSetOutputPortConnected(childS, 0, 1);
4466 _ssSetOutputPortBeingMerged(childS, 0, 0);
4467
4468 /* Update the BufferDstPort flags for each input port */
4469 _ssSetInputPortBufferDstPort(childS, 0, -1);
4470 _ssSetInputPortBufferDstPort(childS, 1, -1);
4471 _ssSetInputPortBufferDstPort(childS, 2, -1);
4472 }
4473
4474 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S96>/Generated S-Function (Gain_sf) */
4475 {
4476 SimStruct *childS = ssGetSFunction(rts, 16);
4477
4478 /* timing info */
4479 time_T *sfcnPeriod;
4480 time_T *sfcnOffset;
4481 int_T *sfcnTsMap;
4482 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
4483 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
4484 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
4485 ss_VALIDATE_MEMORY(rts,sfcnOffset);
4486 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
4487 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
4488 (void) memset((void*)sfcnPeriod, 0,
4489 sizeof(time_T)*1);
4490 (void) memset((void*)sfcnOffset, 0,
4491 sizeof(time_T)*1);
4492 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
4493 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
4494 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
4495
4496 /* Set up the mdlInfo pointer */
4497# ifdef USE_RTMODEL
4498
4499 {
4500 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
4501 struct _ssBlkInfo2));
4502 ss_VALIDATE_MEMORY(rts,blkInfo2);
4503 ssSetBlkInfo2Ptr(childS, blkInfo2);
4504 }
4505
4506 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
4507
4508# else
4509
4510 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
4511
4512# endif /* USE_RTMODEL */
4513
4514 /* Allocate memory of model methods 2 */
4515 {
4516 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
4517 malloc(sizeof(struct _ssSFcnModelMethods2));
4518 ss_VALIDATE_MEMORY(rts,methods2);
4519 ssSetModelMethods2(childS, methods2);
4520 }
4521
4522 /* Allocate memory of model methods 3 */
4523 {
4524 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
4525 malloc(sizeof(struct _ssSFcnModelMethods3));
4526 ss_VALIDATE_MEMORY(rts,methods3);
4527 ssSetModelMethods3(childS, methods3);
4528 }
4529
4530 /* Allocate memory for states auxilliary information */
4531 {
4532 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
4533 (sizeof(struct _ssStatesInfo2));
4534 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
4535 malloc(sizeof(ssPeriodicStatesInfo));
4536 ss_VALIDATE_MEMORY(rts,statesInfo2);
4537 ssSetStatesInfo2(childS, statesInfo2);
4538 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
4539 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
4540 }
4541
4542 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
4543 RegNumInputPorts);
4544 ssSetRegNumInputPortsFcnArg(childS,childS);
4545
4546 /* inputs */
4547 {
4548 struct _ssPortInputs *inputPortInfo =
4549 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
4550 ss_VALIDATE_MEMORY(rts,inputPortInfo);
4551 _ssSetNumInputPorts(childS, 2);
4552 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
4553
4554 /* port 0 */
4555 {
4556 real32_T const **sfcnUPtrs = (real32_T const **)
4557 malloc(1 * sizeof(real32_T *));
4558 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4559 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
4560 ssGetLocalBlockIO(rts))->GeneratedSFunction1;
4561 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
4562 _ssSetInputPortNumDimensions(childS, 0, 1);
4563 ssSetInputPortWidth(childS, 0, 1);
4564 }
4565
4566 /* port 1 */
4567 {
4568 real32_T const **sfcnUPtrs = (real32_T const **)
4569 malloc(1 * sizeof(real32_T *));
4570 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4571 sfcnUPtrs[0] = (real32_T const *)
4572 &AFCS_MODEL1_ConstP.Constant22_Value;
4573 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
4574 _ssSetInputPortNumDimensions(childS, 1, 1);
4575 ssSetInputPortWidth(childS, 1, 1);
4576 }
4577 }
4578
4579 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
4580 RegNumOutputPorts);
4581 ssSetRegNumOutputPortsFcnArg(childS,childS);
4582
4583 /* outputs */
4584 {
4585 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
4586 calloc(1, sizeof(struct _ssPortOutputs));
4587 ss_VALIDATE_MEMORY(rts,outputPortInfo);
4588 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
4589 _ssSetNumOutputPorts(childS, 1);
4590
4591 /* port 0 */
4592 {
4593 _ssSetOutputPortNumDimensions(childS, 0, 1);
4594 ssSetOutputPortWidth(childS, 0, 1);
4595 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
4596 ssGetLocalBlockIO(rts))->GeneratedSFunction_o));
4597 }
4598 }
4599
4600 /* path info */
4601 _ssSetModelName(childS, "Gain_sf");
4602 _ssSetPath(childS,
4603 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/gain2/Generated S-Function");
4604 if (ssGetRTModel(rts) == (NULL)) {
4605 _ssSetParentSS(childS, rts);
4606 _ssSetRootSS(childS, ssGetRootSS(rts));
4607 } else {
4608 ssSetRTModel(childS,ssGetRTModel(rts));
4609 _ssSetParentSS(childS, (NULL));
4610 _ssSetRootSS(childS, childS);
4611 }
4612
4613 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
4614 (childS)->regDataType.arg1 = ((void *)(childS));
4615 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
4616 FcnSetErrorStatus);
4617 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
4618 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
4619 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
4620 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
4621
4622 /* registration */
4623#if defined(MATLAB_MEX_FILE)
4624
4625 {
4626 int_T i;
4627 mxArray *plhs[1];
4628 mxArray *prhs[4];
4629 double *pr;
4630 volatile int_T *intS = (int_T *)&childS;
4631 int_T addrlen = sizeof(SimStruct *);
4632 int_T m = addrlen/sizeof(int_T) + 1;
4633 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
4634 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
4635 pr = mxGetPr(prhs[1]);
4636 for (i = 0; i < m - 1; i++) {
4637 pr[i] = (double)intS[i];
4638 }
4639
4640 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
4641 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
4642 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
4643
4644 /* Reset port dimensions info functions because the S-function
4645 * and accelerator mex-files explicitly set their dimensions,
4646 * i.e., they are not dynamically sized. For this case, the
4647 * mex-file is responsible for the dimensions info memory
4648 * and Simulink should not free it. This is achieved by
4649 * setting the following two methods to NULL.
4650 */
4651 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
4652 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
4653
4654 /*
4655 * Setup function pointers and call mdlInitializeSizes via
4656 * simulink.c
4657 */
4658 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
4659 mxDestroyArray(plhs[0]);
4660 mxDestroyArray(prhs[0]);
4661 mxDestroyArray(prhs[1]);
4662 mxDestroyArray(prhs[2]);
4663 mxDestroyArray(prhs[3]);
4664 }
4665
4666#else
4667
4668 {
4669 Gain_sf(childS);
4670 sfcnInitializeSizes(childS);
4671 }
4672
4673#endif
4674
4675 sfcnInitializeSampleTimes(childS);
4676
4677 /* adjust sample time */
4678 ssSetSampleTime(childS, 0, 0.0);
4679 ssSetOffsetTime(childS, 0, 0.0);
4680 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
4681
4682 /* set compiled values of dynamic vector attributes */
4683 ssSetNumNonsampledZCs(childS, 0);
4684
4685 /* Update connectivity flags for each port */
4686 _ssSetInputPortConnected(childS, 0, 1);
4687 _ssSetInputPortConnected(childS, 1, 1);
4688 _ssSetOutputPortConnected(childS, 0, 1);
4689 _ssSetOutputPortBeingMerged(childS, 0, 0);
4690
4691 /* Update the BufferDstPort flags for each input port */
4692 _ssSetInputPortBufferDstPort(childS, 0, -1);
4693 _ssSetInputPortBufferDstPort(childS, 1, -1);
4694 }
4695
4696 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S93>/Generated S-Function1 (SaturationLimiter_sf) */
4697 {
4698 SimStruct *childS = ssGetSFunction(rts, 17);
4699
4700 /* timing info */
4701 time_T *sfcnPeriod;
4702 time_T *sfcnOffset;
4703 int_T *sfcnTsMap;
4704 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
4705 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
4706 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
4707 ss_VALIDATE_MEMORY(rts,sfcnOffset);
4708 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
4709 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
4710 (void) memset((void*)sfcnPeriod, 0,
4711 sizeof(time_T)*1);
4712 (void) memset((void*)sfcnOffset, 0,
4713 sizeof(time_T)*1);
4714 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
4715 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
4716 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
4717
4718 /* Set up the mdlInfo pointer */
4719# ifdef USE_RTMODEL
4720
4721 {
4722 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
4723 struct _ssBlkInfo2));
4724 ss_VALIDATE_MEMORY(rts,blkInfo2);
4725 ssSetBlkInfo2Ptr(childS, blkInfo2);
4726 }
4727
4728 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
4729
4730# else
4731
4732 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
4733
4734# endif /* USE_RTMODEL */
4735
4736 /* Allocate memory of model methods 2 */
4737 {
4738 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
4739 malloc(sizeof(struct _ssSFcnModelMethods2));
4740 ss_VALIDATE_MEMORY(rts,methods2);
4741 ssSetModelMethods2(childS, methods2);
4742 }
4743
4744 /* Allocate memory of model methods 3 */
4745 {
4746 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
4747 malloc(sizeof(struct _ssSFcnModelMethods3));
4748 ss_VALIDATE_MEMORY(rts,methods3);
4749 ssSetModelMethods3(childS, methods3);
4750 }
4751
4752 /* Allocate memory for states auxilliary information */
4753 {
4754 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
4755 (sizeof(struct _ssStatesInfo2));
4756 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
4757 malloc(sizeof(ssPeriodicStatesInfo));
4758 ss_VALIDATE_MEMORY(rts,statesInfo2);
4759 ssSetStatesInfo2(childS, statesInfo2);
4760 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
4761 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
4762 }
4763
4764 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
4765 RegNumInputPorts);
4766 ssSetRegNumInputPortsFcnArg(childS,childS);
4767
4768 /* inputs */
4769 {
4770 struct _ssPortInputs *inputPortInfo =
4771 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
4772 ss_VALIDATE_MEMORY(rts,inputPortInfo);
4773 _ssSetNumInputPorts(childS, 3);
4774 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
4775
4776 /* port 0 */
4777 {
4778 real32_T const **sfcnUPtrs = (real32_T const **)
4779 malloc(1 * sizeof(real32_T *));
4780 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4781 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
4782 ssGetLocalBlockIO(rts))->Divide2;
4783 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
4784 _ssSetInputPortNumDimensions(childS, 0, 1);
4785 ssSetInputPortWidth(childS, 0, 1);
4786 }
4787
4788 /* port 1 */
4789 {
4790 real32_T const **sfcnUPtrs = (real32_T const **)
4791 malloc(1 * sizeof(real32_T *));
4792 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4793 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;
4794 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
4795 _ssSetInputPortNumDimensions(childS, 1, 1);
4796 ssSetInputPortWidth(childS, 1, 1);
4797 }
4798
4799 /* port 2 */
4800 {
4801 real32_T const **sfcnUPtrs = (real32_T const **)
4802 malloc(1 * sizeof(real32_T *));
4803 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
4804 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;
4805 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
4806 _ssSetInputPortNumDimensions(childS, 2, 1);
4807 ssSetInputPortWidth(childS, 2, 1);
4808 }
4809 }
4810
4811 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
4812 RegNumOutputPorts);
4813 ssSetRegNumOutputPortsFcnArg(childS,childS);
4814
4815 /* outputs */
4816 {
4817 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
4818 calloc(1, sizeof(struct _ssPortOutputs));
4819 ss_VALIDATE_MEMORY(rts,outputPortInfo);
4820 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
4821 _ssSetNumOutputPorts(childS, 1);
4822
4823 /* port 0 */
4824 {
4825 _ssSetOutputPortNumDimensions(childS, 0, 1);
4826 ssSetOutputPortWidth(childS, 0, 1);
4827 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
4828 ssGetLocalBlockIO(rts))->Switch6_d));
4829 }
4830 }
4831
4832 /* path info */
4833 _ssSetModelName(childS, "SaturationLimiter_sf");
4834 _ssSetPath(childS,
4835 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Saturation Limiter3/Generated S-Function1");
4836 if (ssGetRTModel(rts) == (NULL)) {
4837 _ssSetParentSS(childS, rts);
4838 _ssSetRootSS(childS, ssGetRootSS(rts));
4839 } else {
4840 ssSetRTModel(childS,ssGetRTModel(rts));
4841 _ssSetParentSS(childS, (NULL));
4842 _ssSetRootSS(childS, childS);
4843 }
4844
4845 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
4846 (childS)->regDataType.arg1 = ((void *)(childS));
4847 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
4848 FcnSetErrorStatus);
4849 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
4850 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
4851 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
4852 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
4853
4854 /* registration */
4855#if defined(MATLAB_MEX_FILE)
4856
4857 {
4858 int_T i;
4859 mxArray *plhs[1];
4860 mxArray *prhs[4];
4861 double *pr;
4862 volatile int_T *intS = (int_T *)&childS;
4863 int_T addrlen = sizeof(SimStruct *);
4864 int_T m = addrlen/sizeof(int_T) + 1;
4865 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
4866 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
4867 pr = mxGetPr(prhs[1]);
4868 for (i = 0; i < m - 1; i++) {
4869 pr[i] = (double)intS[i];
4870 }
4871
4872 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
4873 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
4874 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
4875
4876 /* Reset port dimensions info functions because the S-function
4877 * and accelerator mex-files explicitly set their dimensions,
4878 * i.e., they are not dynamically sized. For this case, the
4879 * mex-file is responsible for the dimensions info memory
4880 * and Simulink should not free it. This is achieved by
4881 * setting the following two methods to NULL.
4882 */
4883 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
4884 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
4885
4886 /*
4887 * Setup function pointers and call mdlInitializeSizes via
4888 * simulink.c
4889 */
4890 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
4891 mxDestroyArray(plhs[0]);
4892 mxDestroyArray(prhs[0]);
4893 mxDestroyArray(prhs[1]);
4894 mxDestroyArray(prhs[2]);
4895 mxDestroyArray(prhs[3]);
4896 }
4897
4898#else
4899
4900 {
4901 SaturationLimiter_sf(childS);
4902 sfcnInitializeSizes(childS);
4903 }
4904
4905#endif
4906
4907 sfcnInitializeSampleTimes(childS);
4908
4909 /* adjust sample time */
4910 ssSetSampleTime(childS, 0, 0.0);
4911 ssSetOffsetTime(childS, 0, 0.0);
4912 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
4913
4914 /* set compiled values of dynamic vector attributes */
4915 ssSetNumNonsampledZCs(childS, 0);
4916
4917 /* Update connectivity flags for each port */
4918 _ssSetInputPortConnected(childS, 0, 1);
4919 _ssSetInputPortConnected(childS, 1, 1);
4920 _ssSetInputPortConnected(childS, 2, 1);
4921 _ssSetOutputPortConnected(childS, 0, 1);
4922 _ssSetOutputPortBeingMerged(childS, 0, 0);
4923
4924 /* Update the BufferDstPort flags for each input port */
4925 _ssSetInputPortBufferDstPort(childS, 0, -1);
4926 _ssSetInputPortBufferDstPort(childS, 1, -1);
4927 _ssSetInputPortBufferDstPort(childS, 2, -1);
4928 }
4929
4930 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S97>/Generated S-Function (Gain_sf) */
4931 {
4932 SimStruct *childS = ssGetSFunction(rts, 18);
4933
4934 /* timing info */
4935 time_T *sfcnPeriod;
4936 time_T *sfcnOffset;
4937 int_T *sfcnTsMap;
4938 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
4939 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
4940 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
4941 ss_VALIDATE_MEMORY(rts,sfcnOffset);
4942 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
4943 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
4944 (void) memset((void*)sfcnPeriod, 0,
4945 sizeof(time_T)*1);
4946 (void) memset((void*)sfcnOffset, 0,
4947 sizeof(time_T)*1);
4948 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
4949 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
4950 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
4951
4952 /* Set up the mdlInfo pointer */
4953# ifdef USE_RTMODEL
4954
4955 {
4956 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
4957 struct _ssBlkInfo2));
4958 ss_VALIDATE_MEMORY(rts,blkInfo2);
4959 ssSetBlkInfo2Ptr(childS, blkInfo2);
4960 }
4961
4962 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
4963
4964# else
4965
4966 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
4967
4968# endif /* USE_RTMODEL */
4969
4970 /* Allocate memory of model methods 2 */
4971 {
4972 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
4973 malloc(sizeof(struct _ssSFcnModelMethods2));
4974 ss_VALIDATE_MEMORY(rts,methods2);
4975 ssSetModelMethods2(childS, methods2);
4976 }
4977
4978 /* Allocate memory of model methods 3 */
4979 {
4980 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
4981 malloc(sizeof(struct _ssSFcnModelMethods3));
4982 ss_VALIDATE_MEMORY(rts,methods3);
4983 ssSetModelMethods3(childS, methods3);
4984 }
4985
4986 /* Allocate memory for states auxilliary information */
4987 {
4988 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
4989 (sizeof(struct _ssStatesInfo2));
4990 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
4991 malloc(sizeof(ssPeriodicStatesInfo));
4992 ss_VALIDATE_MEMORY(rts,statesInfo2);
4993 ssSetStatesInfo2(childS, statesInfo2);
4994 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
4995 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
4996 }
4997
4998 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
4999 RegNumInputPorts);
5000 ssSetRegNumInputPortsFcnArg(childS,childS);
5001
5002 /* inputs */
5003 {
5004 struct _ssPortInputs *inputPortInfo =
5005 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
5006 ss_VALIDATE_MEMORY(rts,inputPortInfo);
5007 _ssSetNumInputPorts(childS, 2);
5008 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
5009
5010 /* port 0 */
5011 {
5012 real32_T const **sfcnUPtrs = (real32_T const **)
5013 malloc(1 * sizeof(real32_T *));
5014 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5015 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
5016 ssGetLocalBlockIO(rts))->GeneratedSFunction_o;
5017 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
5018 _ssSetInputPortNumDimensions(childS, 0, 1);
5019 ssSetInputPortWidth(childS, 0, 1);
5020 }
5021
5022 /* port 1 */
5023 {
5024 real32_T const **sfcnUPtrs = (real32_T const **)
5025 malloc(1 * sizeof(real32_T *));
5026 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5027 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
5028 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
5029 _ssSetInputPortNumDimensions(childS, 1, 1);
5030 ssSetInputPortWidth(childS, 1, 1);
5031 }
5032 }
5033
5034 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
5035 RegNumOutputPorts);
5036 ssSetRegNumOutputPortsFcnArg(childS,childS);
5037
5038 /* outputs */
5039 {
5040 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
5041 calloc(1, sizeof(struct _ssPortOutputs));
5042 ss_VALIDATE_MEMORY(rts,outputPortInfo);
5043 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
5044 _ssSetNumOutputPorts(childS, 1);
5045
5046 /* port 0 */
5047 {
5048 _ssSetOutputPortNumDimensions(childS, 0, 1);
5049 ssSetOutputPortWidth(childS, 0, 1);
5050 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
5051 ssGetLocalBlockIO(rts))->GeneratedSFunction_jq));
5052 }
5053 }
5054
5055 /* path info */
5056 _ssSetModelName(childS, "Gain_sf");
5057 _ssSetPath(childS,
5058 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/gain4/Generated S-Function");
5059 if (ssGetRTModel(rts) == (NULL)) {
5060 _ssSetParentSS(childS, rts);
5061 _ssSetRootSS(childS, ssGetRootSS(rts));
5062 } else {
5063 ssSetRTModel(childS,ssGetRTModel(rts));
5064 _ssSetParentSS(childS, (NULL));
5065 _ssSetRootSS(childS, childS);
5066 }
5067
5068 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
5069 (childS)->regDataType.arg1 = ((void *)(childS));
5070 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
5071 FcnSetErrorStatus);
5072 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
5073 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
5074 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
5075 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
5076
5077 /* registration */
5078#if defined(MATLAB_MEX_FILE)
5079
5080 {
5081 int_T i;
5082 mxArray *plhs[1];
5083 mxArray *prhs[4];
5084 double *pr;
5085 volatile int_T *intS = (int_T *)&childS;
5086 int_T addrlen = sizeof(SimStruct *);
5087 int_T m = addrlen/sizeof(int_T) + 1;
5088 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
5089 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
5090 pr = mxGetPr(prhs[1]);
5091 for (i = 0; i < m - 1; i++) {
5092 pr[i] = (double)intS[i];
5093 }
5094
5095 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
5096 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
5097 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
5098
5099 /* Reset port dimensions info functions because the S-function
5100 * and accelerator mex-files explicitly set their dimensions,
5101 * i.e., they are not dynamically sized. For this case, the
5102 * mex-file is responsible for the dimensions info memory
5103 * and Simulink should not free it. This is achieved by
5104 * setting the following two methods to NULL.
5105 */
5106 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
5107 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
5108
5109 /*
5110 * Setup function pointers and call mdlInitializeSizes via
5111 * simulink.c
5112 */
5113 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
5114 mxDestroyArray(plhs[0]);
5115 mxDestroyArray(prhs[0]);
5116 mxDestroyArray(prhs[1]);
5117 mxDestroyArray(prhs[2]);
5118 mxDestroyArray(prhs[3]);
5119 }
5120
5121#else
5122
5123 {
5124 Gain_sf(childS);
5125 sfcnInitializeSizes(childS);
5126 }
5127
5128#endif
5129
5130 sfcnInitializeSampleTimes(childS);
5131
5132 /* adjust sample time */
5133 ssSetSampleTime(childS, 0, 0.0);
5134 ssSetOffsetTime(childS, 0, 0.0);
5135 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
5136
5137 /* set compiled values of dynamic vector attributes */
5138 ssSetNumNonsampledZCs(childS, 0);
5139
5140 /* Update connectivity flags for each port */
5141 _ssSetInputPortConnected(childS, 0, 1);
5142 _ssSetInputPortConnected(childS, 1, 1);
5143 _ssSetOutputPortConnected(childS, 0, 1);
5144 _ssSetOutputPortBeingMerged(childS, 0, 0);
5145
5146 /* Update the BufferDstPort flags for each input port */
5147 _ssSetInputPortBufferDstPort(childS, 0, -1);
5148 _ssSetInputPortBufferDstPort(childS, 1, -1);
5149 }
5150
5151 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S89>/Generated S-Function3 (IntegratorLimited_sf) */
5152 {
5153 SimStruct *childS = ssGetSFunction(rts, 19);
5154
5155 /* timing info */
5156 time_T *sfcnPeriod;
5157 time_T *sfcnOffset;
5158 int_T *sfcnTsMap;
5159 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
5160 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
5161 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
5162 ss_VALIDATE_MEMORY(rts,sfcnOffset);
5163 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
5164 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
5165 (void) memset((void*)sfcnPeriod, 0,
5166 sizeof(time_T)*1);
5167 (void) memset((void*)sfcnOffset, 0,
5168 sizeof(time_T)*1);
5169 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
5170 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
5171 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
5172
5173 /* Set up the mdlInfo pointer */
5174# ifdef USE_RTMODEL
5175
5176 {
5177 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
5178 struct _ssBlkInfo2));
5179 ss_VALIDATE_MEMORY(rts,blkInfo2);
5180 ssSetBlkInfo2Ptr(childS, blkInfo2);
5181 }
5182
5183 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
5184
5185# else
5186
5187 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
5188
5189# endif /* USE_RTMODEL */
5190
5191 /* Allocate memory of model methods 2 */
5192 {
5193 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
5194 malloc(sizeof(struct _ssSFcnModelMethods2));
5195 ss_VALIDATE_MEMORY(rts,methods2);
5196 ssSetModelMethods2(childS, methods2);
5197 }
5198
5199 /* Allocate memory of model methods 3 */
5200 {
5201 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
5202 malloc(sizeof(struct _ssSFcnModelMethods3));
5203 ss_VALIDATE_MEMORY(rts,methods3);
5204 ssSetModelMethods3(childS, methods3);
5205 }
5206
5207 /* Allocate memory for states auxilliary information */
5208 {
5209 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
5210 (sizeof(struct _ssStatesInfo2));
5211 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
5212 malloc(sizeof(ssPeriodicStatesInfo));
5213 ss_VALIDATE_MEMORY(rts,statesInfo2);
5214 ssSetStatesInfo2(childS, statesInfo2);
5215 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
5216 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
5217 }
5218
5219 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
5220 RegNumInputPorts);
5221 ssSetRegNumInputPortsFcnArg(childS,childS);
5222
5223 /* inputs */
5224 {
5225 struct _ssPortInputs *inputPortInfo =
5226 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
5227 ss_VALIDATE_MEMORY(rts,inputPortInfo);
5228 _ssSetNumInputPorts(childS, 7);
5229 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
5230
5231 /* port 0 */
5232 {
5233 real32_T const **sfcnUPtrs = (real32_T const **)
5234 malloc(1 * sizeof(real32_T *));
5235 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5236 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
5237 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
5238 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
5239 _ssSetInputPortNumDimensions(childS, 0, 1);
5240 ssSetInputPortWidth(childS, 0, 1);
5241 }
5242
5243 /* port 1 */
5244 {
5245 int8_T const **sfcnUPtrs = (int8_T const **)
5246 malloc(1 * sizeof(int8_T *));
5247 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5248 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
5249 ssGetLocalBlockIO(rts))->DataTypeConversion3_c;
5250 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
5251 _ssSetInputPortNumDimensions(childS, 1, 1);
5252 ssSetInputPortWidth(childS, 1, 1);
5253 }
5254
5255 /* port 2 */
5256 {
5257 real32_T const **sfcnUPtrs = (real32_T const **)
5258 malloc(1 * sizeof(real32_T *));
5259 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5260 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
5261 ssGetLocalBlockIO(rts))->Sum8;
5262 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
5263 _ssSetInputPortNumDimensions(childS, 2, 1);
5264 ssSetInputPortWidth(childS, 2, 1);
5265 }
5266
5267 /* port 3 */
5268 {
5269 real32_T const **sfcnUPtrs = (real32_T const **)
5270 malloc(1 * sizeof(real32_T *));
5271 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5272 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
5273 ssGetLocalBlockIO(rts))->Sum8;
5274 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
5275 _ssSetInputPortNumDimensions(childS, 3, 1);
5276 ssSetInputPortWidth(childS, 3, 1);
5277 }
5278
5279 /* port 4 */
5280 {
5281 real32_T const **sfcnUPtrs = (real32_T const **)
5282 malloc(1 * sizeof(real32_T *));
5283 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5284 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;
5285 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
5286 _ssSetInputPortNumDimensions(childS, 4, 1);
5287 ssSetInputPortWidth(childS, 4, 1);
5288 }
5289
5290 /* port 5 */
5291 {
5292 real32_T const **sfcnUPtrs = (real32_T const **)
5293 malloc(1 * sizeof(real32_T *));
5294 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5295 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;
5296 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
5297 _ssSetInputPortNumDimensions(childS, 5, 1);
5298 ssSetInputPortWidth(childS, 5, 1);
5299 }
5300
5301 /* port 6 */
5302 {
5303 real32_T const **sfcnUPtrs = (real32_T const **)
5304 malloc(1 * sizeof(real32_T *));
5305 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5306 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
5307 ssGetLocalBlockIO(rts))->GeneratedSFunction_jq;
5308 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
5309 _ssSetInputPortNumDimensions(childS, 6, 1);
5310 ssSetInputPortWidth(childS, 6, 1);
5311 }
5312 }
5313
5314 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
5315 RegNumOutputPorts);
5316 ssSetRegNumOutputPortsFcnArg(childS,childS);
5317
5318 /* outputs */
5319 {
5320 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
5321 calloc(1, sizeof(struct _ssPortOutputs));
5322 ss_VALIDATE_MEMORY(rts,outputPortInfo);
5323 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
5324 _ssSetNumOutputPorts(childS, 1);
5325
5326 /* port 0 */
5327 {
5328 _ssSetOutputPortNumDimensions(childS, 0, 1);
5329 ssSetOutputPortWidth(childS, 0, 1);
5330 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
5331 ssGetLocalBlockIO(rts))->Switch6_d));
5332 }
5333 }
5334
5335 /* path info */
5336 _ssSetModelName(childS, "IntegratorLimited_sf");
5337 _ssSetPath(childS,
5338 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Integrator Limited1/Generated S-Function3");
5339 if (ssGetRTModel(rts) == (NULL)) {
5340 _ssSetParentSS(childS, rts);
5341 _ssSetRootSS(childS, ssGetRootSS(rts));
5342 } else {
5343 ssSetRTModel(childS,ssGetRTModel(rts));
5344 _ssSetParentSS(childS, (NULL));
5345 _ssSetRootSS(childS, childS);
5346 }
5347
5348 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
5349
5350 /* work vectors */
5351 {
5352 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
5353 (4 * sizeof(struct _ssDWorkRecord));
5354 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
5355 calloc(4, sizeof(struct _ssDWorkAuxRecord));
5356 ss_VALIDATE_MEMORY(rts,dWorkRecord);
5357 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
5358 ssSetSFcnDWork(childS, dWorkRecord);
5359 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
5360 _ssSetNumDWork(childS, 4);
5361
5362 /* DWORK0 */
5363 ssSetDWorkWidth(childS, 0, 1);
5364 ssSetDWorkDataType(childS, 0,SS_SINGLE);
5365 ssSetDWorkComplexSignal(childS, 0, 0);
5366 ssSetDWorkUsedAsDState(childS, 0, 1);
5367 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 162))[0]);
5368
5369 /* DWORK1 */
5370 ssSetDWorkWidth(childS, 1, 1);
5371 ssSetDWorkDataType(childS, 1,SS_SINGLE);
5372 ssSetDWorkComplexSignal(childS, 1, 0);
5373 ssSetDWorkUsedAsDState(childS, 1, 1);
5374 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 163))[0]);
5375
5376 /* DWORK2 */
5377 ssSetDWorkWidth(childS, 2, 1);
5378 ssSetDWorkDataType(childS, 2,SS_INT8);
5379 ssSetDWorkComplexSignal(childS, 2, 0);
5380 ssSetDWorkUsedAsDState(childS, 2, 1);
5381 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 389))[0]);
5382
5383 /* DWORK3 */
5384 ssSetDWorkWidth(childS, 3, 1);
5385 ssSetDWorkDataType(childS, 3,SS_INT8);
5386 ssSetDWorkComplexSignal(childS, 3, 0);
5387 ssSetDWorkUsedAsDState(childS, 3, 1);
5388 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 390))[0]);
5389 }
5390
5391 (childS)->regDataType.arg1 = ((void *)(childS));
5392 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
5393 FcnSetErrorStatus);
5394 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
5395 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
5396 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
5397 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
5398
5399 /* registration */
5400#if defined(MATLAB_MEX_FILE)
5401
5402 {
5403 int_T i;
5404 mxArray *plhs[1];
5405 mxArray *prhs[4];
5406 double *pr;
5407 volatile int_T *intS = (int_T *)&childS;
5408 int_T addrlen = sizeof(SimStruct *);
5409 int_T m = addrlen/sizeof(int_T) + 1;
5410 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
5411 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
5412 pr = mxGetPr(prhs[1]);
5413 for (i = 0; i < m - 1; i++) {
5414 pr[i] = (double)intS[i];
5415 }
5416
5417 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
5418 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
5419 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
5420
5421 /* Reset port dimensions info functions because the S-function
5422 * and accelerator mex-files explicitly set their dimensions,
5423 * i.e., they are not dynamically sized. For this case, the
5424 * mex-file is responsible for the dimensions info memory
5425 * and Simulink should not free it. This is achieved by
5426 * setting the following two methods to NULL.
5427 */
5428 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
5429 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
5430
5431 /*
5432 * Setup function pointers and call mdlInitializeSizes via
5433 * simulink.c
5434 */
5435 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
5436 mxDestroyArray(plhs[0]);
5437 mxDestroyArray(prhs[0]);
5438 mxDestroyArray(prhs[1]);
5439 mxDestroyArray(prhs[2]);
5440 mxDestroyArray(prhs[3]);
5441 }
5442
5443#else
5444
5445 {
5446 IntegratorLimited_sf(childS);
5447 sfcnInitializeSizes(childS);
5448 }
5449
5450#endif
5451
5452 sfcnInitializeSampleTimes(childS);
5453
5454 /* adjust sample time */
5455 ssSetSampleTime(childS, 0, 0.0);
5456 ssSetOffsetTime(childS, 0, 0.0);
5457 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
5458
5459 /* set compiled values of dynamic vector attributes */
5460 ssSetNumNonsampledZCs(childS, 0);
5461
5462 /* Update connectivity flags for each port */
5463 _ssSetInputPortConnected(childS, 0, 1);
5464 _ssSetInputPortConnected(childS, 1, 1);
5465 _ssSetInputPortConnected(childS, 2, 1);
5466 _ssSetInputPortConnected(childS, 3, 1);
5467 _ssSetInputPortConnected(childS, 4, 1);
5468 _ssSetInputPortConnected(childS, 5, 1);
5469 _ssSetInputPortConnected(childS, 6, 1);
5470 _ssSetOutputPortConnected(childS, 0, 1);
5471 _ssSetOutputPortBeingMerged(childS, 0, 0);
5472
5473 /* Update the BufferDstPort flags for each input port */
5474 _ssSetInputPortBufferDstPort(childS, 0, -1);
5475 _ssSetInputPortBufferDstPort(childS, 1, -1);
5476 _ssSetInputPortBufferDstPort(childS, 2, -1);
5477 _ssSetInputPortBufferDstPort(childS, 3, -1);
5478 _ssSetInputPortBufferDstPort(childS, 4, -1);
5479 _ssSetInputPortBufferDstPort(childS, 5, -1);
5480 _ssSetInputPortBufferDstPort(childS, 6, -1);
5481 }
5482
5483 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S91>/Generated S-Function1 (SaturationLimiter_sf) */
5484 {
5485 SimStruct *childS = ssGetSFunction(rts, 20);
5486
5487 /* timing info */
5488 time_T *sfcnPeriod;
5489 time_T *sfcnOffset;
5490 int_T *sfcnTsMap;
5491 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
5492 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
5493 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
5494 ss_VALIDATE_MEMORY(rts,sfcnOffset);
5495 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
5496 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
5497 (void) memset((void*)sfcnPeriod, 0,
5498 sizeof(time_T)*1);
5499 (void) memset((void*)sfcnOffset, 0,
5500 sizeof(time_T)*1);
5501 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
5502 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
5503 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
5504
5505 /* Set up the mdlInfo pointer */
5506# ifdef USE_RTMODEL
5507
5508 {
5509 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
5510 struct _ssBlkInfo2));
5511 ss_VALIDATE_MEMORY(rts,blkInfo2);
5512 ssSetBlkInfo2Ptr(childS, blkInfo2);
5513 }
5514
5515 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
5516
5517# else
5518
5519 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
5520
5521# endif /* USE_RTMODEL */
5522
5523 /* Allocate memory of model methods 2 */
5524 {
5525 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
5526 malloc(sizeof(struct _ssSFcnModelMethods2));
5527 ss_VALIDATE_MEMORY(rts,methods2);
5528 ssSetModelMethods2(childS, methods2);
5529 }
5530
5531 /* Allocate memory of model methods 3 */
5532 {
5533 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
5534 malloc(sizeof(struct _ssSFcnModelMethods3));
5535 ss_VALIDATE_MEMORY(rts,methods3);
5536 ssSetModelMethods3(childS, methods3);
5537 }
5538
5539 /* Allocate memory for states auxilliary information */
5540 {
5541 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
5542 (sizeof(struct _ssStatesInfo2));
5543 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
5544 malloc(sizeof(ssPeriodicStatesInfo));
5545 ss_VALIDATE_MEMORY(rts,statesInfo2);
5546 ssSetStatesInfo2(childS, statesInfo2);
5547 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
5548 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
5549 }
5550
5551 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
5552 RegNumInputPorts);
5553 ssSetRegNumInputPortsFcnArg(childS,childS);
5554
5555 /* inputs */
5556 {
5557 struct _ssPortInputs *inputPortInfo =
5558 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
5559 ss_VALIDATE_MEMORY(rts,inputPortInfo);
5560 _ssSetNumInputPorts(childS, 3);
5561 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
5562
5563 /* port 0 */
5564 {
5565 real32_T const **sfcnUPtrs = (real32_T const **)
5566 malloc(1 * sizeof(real32_T *));
5567 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5568 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
5569 ssGetLocalBlockIO(rts))->Sum1_j;
5570 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
5571 _ssSetInputPortNumDimensions(childS, 0, 1);
5572 ssSetInputPortWidth(childS, 0, 1);
5573 }
5574
5575 /* port 1 */
5576 {
5577 real32_T const **sfcnUPtrs = (real32_T const **)
5578 malloc(1 * sizeof(real32_T *));
5579 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5580 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;
5581 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
5582 _ssSetInputPortNumDimensions(childS, 1, 1);
5583 ssSetInputPortWidth(childS, 1, 1);
5584 }
5585
5586 /* port 2 */
5587 {
5588 real32_T const **sfcnUPtrs = (real32_T const **)
5589 malloc(1 * sizeof(real32_T *));
5590 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5591 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;
5592 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
5593 _ssSetInputPortNumDimensions(childS, 2, 1);
5594 ssSetInputPortWidth(childS, 2, 1);
5595 }
5596 }
5597
5598 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
5599 RegNumOutputPorts);
5600 ssSetRegNumOutputPortsFcnArg(childS,childS);
5601
5602 /* outputs */
5603 {
5604 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
5605 calloc(1, sizeof(struct _ssPortOutputs));
5606 ss_VALIDATE_MEMORY(rts,outputPortInfo);
5607 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
5608 _ssSetNumOutputPorts(childS, 1);
5609
5610 /* port 0 */
5611 {
5612 _ssSetOutputPortNumDimensions(childS, 0, 1);
5613 ssSetOutputPortWidth(childS, 0, 1);
5614 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
5615 ssGetLocalBlockIO(rts))->GeneratedSFunction1_h));
5616 }
5617 }
5618
5619 /* path info */
5620 _ssSetModelName(childS, "SaturationLimiter_sf");
5621 _ssSetPath(childS,
5622 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Saturation Limiter1/Generated S-Function1");
5623 if (ssGetRTModel(rts) == (NULL)) {
5624 _ssSetParentSS(childS, rts);
5625 _ssSetRootSS(childS, ssGetRootSS(rts));
5626 } else {
5627 ssSetRTModel(childS,ssGetRTModel(rts));
5628 _ssSetParentSS(childS, (NULL));
5629 _ssSetRootSS(childS, childS);
5630 }
5631
5632 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
5633 (childS)->regDataType.arg1 = ((void *)(childS));
5634 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
5635 FcnSetErrorStatus);
5636 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
5637 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
5638 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
5639 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
5640
5641 /* registration */
5642#if defined(MATLAB_MEX_FILE)
5643
5644 {
5645 int_T i;
5646 mxArray *plhs[1];
5647 mxArray *prhs[4];
5648 double *pr;
5649 volatile int_T *intS = (int_T *)&childS;
5650 int_T addrlen = sizeof(SimStruct *);
5651 int_T m = addrlen/sizeof(int_T) + 1;
5652 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
5653 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
5654 pr = mxGetPr(prhs[1]);
5655 for (i = 0; i < m - 1; i++) {
5656 pr[i] = (double)intS[i];
5657 }
5658
5659 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
5660 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
5661 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
5662
5663 /* Reset port dimensions info functions because the S-function
5664 * and accelerator mex-files explicitly set their dimensions,
5665 * i.e., they are not dynamically sized. For this case, the
5666 * mex-file is responsible for the dimensions info memory
5667 * and Simulink should not free it. This is achieved by
5668 * setting the following two methods to NULL.
5669 */
5670 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
5671 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
5672
5673 /*
5674 * Setup function pointers and call mdlInitializeSizes via
5675 * simulink.c
5676 */
5677 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
5678 mxDestroyArray(plhs[0]);
5679 mxDestroyArray(prhs[0]);
5680 mxDestroyArray(prhs[1]);
5681 mxDestroyArray(prhs[2]);
5682 mxDestroyArray(prhs[3]);
5683 }
5684
5685#else
5686
5687 {
5688 SaturationLimiter_sf(childS);
5689 sfcnInitializeSizes(childS);
5690 }
5691
5692#endif
5693
5694 sfcnInitializeSampleTimes(childS);
5695
5696 /* adjust sample time */
5697 ssSetSampleTime(childS, 0, 0.0);
5698 ssSetOffsetTime(childS, 0, 0.0);
5699 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
5700
5701 /* set compiled values of dynamic vector attributes */
5702 ssSetNumNonsampledZCs(childS, 0);
5703
5704 /* Update connectivity flags for each port */
5705 _ssSetInputPortConnected(childS, 0, 1);
5706 _ssSetInputPortConnected(childS, 1, 1);
5707 _ssSetInputPortConnected(childS, 2, 1);
5708 _ssSetOutputPortConnected(childS, 0, 1);
5709 _ssSetOutputPortBeingMerged(childS, 0, 0);
5710
5711 /* Update the BufferDstPort flags for each input port */
5712 _ssSetInputPortBufferDstPort(childS, 0, -1);
5713 _ssSetInputPortBufferDstPort(childS, 1, -1);
5714 _ssSetInputPortBufferDstPort(childS, 2, -1);
5715 }
5716
5717 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S95>/Generated S-Function (Gain_sf) */
5718 {
5719 SimStruct *childS = ssGetSFunction(rts, 21);
5720
5721 /* timing info */
5722 time_T *sfcnPeriod;
5723 time_T *sfcnOffset;
5724 int_T *sfcnTsMap;
5725 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
5726 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
5727 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
5728 ss_VALIDATE_MEMORY(rts,sfcnOffset);
5729 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
5730 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
5731 (void) memset((void*)sfcnPeriod, 0,
5732 sizeof(time_T)*1);
5733 (void) memset((void*)sfcnOffset, 0,
5734 sizeof(time_T)*1);
5735 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
5736 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
5737 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
5738
5739 /* Set up the mdlInfo pointer */
5740# ifdef USE_RTMODEL
5741
5742 {
5743 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
5744 struct _ssBlkInfo2));
5745 ss_VALIDATE_MEMORY(rts,blkInfo2);
5746 ssSetBlkInfo2Ptr(childS, blkInfo2);
5747 }
5748
5749 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
5750
5751# else
5752
5753 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
5754
5755# endif /* USE_RTMODEL */
5756
5757 /* Allocate memory of model methods 2 */
5758 {
5759 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
5760 malloc(sizeof(struct _ssSFcnModelMethods2));
5761 ss_VALIDATE_MEMORY(rts,methods2);
5762 ssSetModelMethods2(childS, methods2);
5763 }
5764
5765 /* Allocate memory of model methods 3 */
5766 {
5767 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
5768 malloc(sizeof(struct _ssSFcnModelMethods3));
5769 ss_VALIDATE_MEMORY(rts,methods3);
5770 ssSetModelMethods3(childS, methods3);
5771 }
5772
5773 /* Allocate memory for states auxilliary information */
5774 {
5775 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
5776 (sizeof(struct _ssStatesInfo2));
5777 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
5778 malloc(sizeof(ssPeriodicStatesInfo));
5779 ss_VALIDATE_MEMORY(rts,statesInfo2);
5780 ssSetStatesInfo2(childS, statesInfo2);
5781 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
5782 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
5783 }
5784
5785 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
5786 RegNumInputPorts);
5787 ssSetRegNumInputPortsFcnArg(childS,childS);
5788
5789 /* inputs */
5790 {
5791 struct _ssPortInputs *inputPortInfo =
5792 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
5793 ss_VALIDATE_MEMORY(rts,inputPortInfo);
5794 _ssSetNumInputPorts(childS, 2);
5795 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
5796
5797 /* port 0 */
5798 {
5799 real32_T const **sfcnUPtrs = (real32_T const **)
5800 malloc(1 * sizeof(real32_T *));
5801 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5802 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
5803 ssGetLocalBlockIO(rts))->GeneratedSFunction1_h;
5804 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
5805 _ssSetInputPortNumDimensions(childS, 0, 1);
5806 ssSetInputPortWidth(childS, 0, 1);
5807 }
5808
5809 /* port 1 */
5810 {
5811 real32_T const **sfcnUPtrs = (real32_T const **)
5812 malloc(1 * sizeof(real32_T *));
5813 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
5814 sfcnUPtrs[0] = (real32_T const *)
5815 &AFCS_MODEL1_ConstP.Constant13_Value_n;
5816 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
5817 _ssSetInputPortNumDimensions(childS, 1, 1);
5818 ssSetInputPortWidth(childS, 1, 1);
5819 }
5820 }
5821
5822 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
5823 RegNumOutputPorts);
5824 ssSetRegNumOutputPortsFcnArg(childS,childS);
5825
5826 /* outputs */
5827 {
5828 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
5829 calloc(1, sizeof(struct _ssPortOutputs));
5830 ss_VALIDATE_MEMORY(rts,outputPortInfo);
5831 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
5832 _ssSetNumOutputPorts(childS, 1);
5833
5834 /* port 0 */
5835 {
5836 _ssSetOutputPortNumDimensions(childS, 0, 1);
5837 ssSetOutputPortWidth(childS, 0, 1);
5838 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
5839 ssGetLocalBlockIO(rts))->Saturation8));
5840 }
5841 }
5842
5843 /* path info */
5844 _ssSetModelName(childS, "Gain_sf");
5845 _ssSetPath(childS,
5846 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/gain/Generated S-Function");
5847 if (ssGetRTModel(rts) == (NULL)) {
5848 _ssSetParentSS(childS, rts);
5849 _ssSetRootSS(childS, ssGetRootSS(rts));
5850 } else {
5851 ssSetRTModel(childS,ssGetRTModel(rts));
5852 _ssSetParentSS(childS, (NULL));
5853 _ssSetRootSS(childS, childS);
5854 }
5855
5856 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
5857 (childS)->regDataType.arg1 = ((void *)(childS));
5858 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
5859 FcnSetErrorStatus);
5860 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
5861 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
5862 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
5863 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
5864
5865 /* registration */
5866#if defined(MATLAB_MEX_FILE)
5867
5868 {
5869 int_T i;
5870 mxArray *plhs[1];
5871 mxArray *prhs[4];
5872 double *pr;
5873 volatile int_T *intS = (int_T *)&childS;
5874 int_T addrlen = sizeof(SimStruct *);
5875 int_T m = addrlen/sizeof(int_T) + 1;
5876 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
5877 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
5878 pr = mxGetPr(prhs[1]);
5879 for (i = 0; i < m - 1; i++) {
5880 pr[i] = (double)intS[i];
5881 }
5882
5883 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
5884 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
5885 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
5886
5887 /* Reset port dimensions info functions because the S-function
5888 * and accelerator mex-files explicitly set their dimensions,
5889 * i.e., they are not dynamically sized. For this case, the
5890 * mex-file is responsible for the dimensions info memory
5891 * and Simulink should not free it. This is achieved by
5892 * setting the following two methods to NULL.
5893 */
5894 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
5895 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
5896
5897 /*
5898 * Setup function pointers and call mdlInitializeSizes via
5899 * simulink.c
5900 */
5901 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
5902 mxDestroyArray(plhs[0]);
5903 mxDestroyArray(prhs[0]);
5904 mxDestroyArray(prhs[1]);
5905 mxDestroyArray(prhs[2]);
5906 mxDestroyArray(prhs[3]);
5907 }
5908
5909#else
5910
5911 {
5912 Gain_sf(childS);
5913 sfcnInitializeSizes(childS);
5914 }
5915
5916#endif
5917
5918 sfcnInitializeSampleTimes(childS);
5919
5920 /* adjust sample time */
5921 ssSetSampleTime(childS, 0, 0.0);
5922 ssSetOffsetTime(childS, 0, 0.0);
5923 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
5924
5925 /* set compiled values of dynamic vector attributes */
5926 ssSetNumNonsampledZCs(childS, 0);
5927
5928 /* Update connectivity flags for each port */
5929 _ssSetInputPortConnected(childS, 0, 1);
5930 _ssSetInputPortConnected(childS, 1, 1);
5931 _ssSetOutputPortConnected(childS, 0, 1);
5932 _ssSetOutputPortBeingMerged(childS, 0, 0);
5933
5934 /* Update the BufferDstPort flags for each input port */
5935 _ssSetInputPortBufferDstPort(childS, 0, -1);
5936 _ssSetInputPortBufferDstPort(childS, 1, -1);
5937 }
5938
5939 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S90>/Generated S-Function2 (LeadLagFilter_sf) */
5940 {
5941 SimStruct *childS = ssGetSFunction(rts, 22);
5942
5943 /* timing info */
5944 time_T *sfcnPeriod;
5945 time_T *sfcnOffset;
5946 int_T *sfcnTsMap;
5947 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
5948 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
5949 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
5950 ss_VALIDATE_MEMORY(rts,sfcnOffset);
5951 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
5952 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
5953 (void) memset((void*)sfcnPeriod, 0,
5954 sizeof(time_T)*1);
5955 (void) memset((void*)sfcnOffset, 0,
5956 sizeof(time_T)*1);
5957 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
5958 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
5959 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
5960
5961 /* Set up the mdlInfo pointer */
5962# ifdef USE_RTMODEL
5963
5964 {
5965 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
5966 struct _ssBlkInfo2));
5967 ss_VALIDATE_MEMORY(rts,blkInfo2);
5968 ssSetBlkInfo2Ptr(childS, blkInfo2);
5969 }
5970
5971 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
5972
5973# else
5974
5975 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
5976
5977# endif /* USE_RTMODEL */
5978
5979 /* Allocate memory of model methods 2 */
5980 {
5981 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
5982 malloc(sizeof(struct _ssSFcnModelMethods2));
5983 ss_VALIDATE_MEMORY(rts,methods2);
5984 ssSetModelMethods2(childS, methods2);
5985 }
5986
5987 /* Allocate memory of model methods 3 */
5988 {
5989 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
5990 malloc(sizeof(struct _ssSFcnModelMethods3));
5991 ss_VALIDATE_MEMORY(rts,methods3);
5992 ssSetModelMethods3(childS, methods3);
5993 }
5994
5995 /* Allocate memory for states auxilliary information */
5996 {
5997 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
5998 (sizeof(struct _ssStatesInfo2));
5999 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
6000 malloc(sizeof(ssPeriodicStatesInfo));
6001 ss_VALIDATE_MEMORY(rts,statesInfo2);
6002 ssSetStatesInfo2(childS, statesInfo2);
6003 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
6004 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
6005 }
6006
6007 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
6008 RegNumInputPorts);
6009 ssSetRegNumInputPortsFcnArg(childS,childS);
6010
6011 /* inputs */
6012 {
6013 struct _ssPortInputs *inputPortInfo =
6014 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
6015 ss_VALIDATE_MEMORY(rts,inputPortInfo);
6016 _ssSetNumInputPorts(childS, 7);
6017 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
6018
6019 /* port 0 */
6020 {
6021 real32_T const **sfcnUPtrs = (real32_T const **)
6022 malloc(1 * sizeof(real32_T *));
6023 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6024 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6025 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
6026 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
6027 _ssSetInputPortNumDimensions(childS, 0, 1);
6028 ssSetInputPortWidth(childS, 0, 1);
6029 }
6030
6031 /* port 1 */
6032 {
6033 int8_T const **sfcnUPtrs = (int8_T const **)
6034 malloc(1 * sizeof(int8_T *));
6035 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6036 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
6037 ssGetLocalBlockIO(rts))->DataTypeConversion3_c;
6038 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
6039 _ssSetInputPortNumDimensions(childS, 1, 1);
6040 ssSetInputPortWidth(childS, 1, 1);
6041 }
6042
6043 /* port 2 */
6044 {
6045 real32_T const **sfcnUPtrs = (real32_T const **)
6046 malloc(1 * sizeof(real32_T *));
6047 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6048 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
6049 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
6050 _ssSetInputPortNumDimensions(childS, 2, 1);
6051 ssSetInputPortWidth(childS, 2, 1);
6052 }
6053
6054 /* port 3 */
6055 {
6056 real32_T const **sfcnUPtrs = (real32_T const **)
6057 malloc(1 * sizeof(real32_T *));
6058 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6059 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;
6060 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
6061 _ssSetInputPortNumDimensions(childS, 3, 1);
6062 ssSetInputPortWidth(childS, 3, 1);
6063 }
6064
6065 /* port 4 */
6066 {
6067 real32_T const **sfcnUPtrs = (real32_T const **)
6068 malloc(1 * sizeof(real32_T *));
6069 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6070 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6071 ssGetLocalBlockIO(rts))->Switch_aj;
6072 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
6073 _ssSetInputPortNumDimensions(childS, 4, 1);
6074 ssSetInputPortWidth(childS, 4, 1);
6075 }
6076
6077 /* port 5 */
6078 {
6079 real32_T const **sfcnUPtrs = (real32_T const **)
6080 malloc(1 * sizeof(real32_T *));
6081 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6082 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6083 ssGetLocalBlockIO(rts))->Switch_aj;
6084 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
6085 _ssSetInputPortNumDimensions(childS, 5, 1);
6086 ssSetInputPortWidth(childS, 5, 1);
6087 }
6088
6089 /* port 6 */
6090 {
6091 real32_T const **sfcnUPtrs = (real32_T const **)
6092 malloc(1 * sizeof(real32_T *));
6093 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6094 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6095 ssGetLocalBlockIO(rts))->Divide;
6096 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
6097 _ssSetInputPortNumDimensions(childS, 6, 1);
6098 ssSetInputPortWidth(childS, 6, 1);
6099 }
6100 }
6101
6102 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
6103 RegNumOutputPorts);
6104 ssSetRegNumOutputPortsFcnArg(childS,childS);
6105
6106 /* outputs */
6107 {
6108 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
6109 calloc(1, sizeof(struct _ssPortOutputs));
6110 ss_VALIDATE_MEMORY(rts,outputPortInfo);
6111 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
6112 _ssSetNumOutputPorts(childS, 1);
6113
6114 /* port 0 */
6115 {
6116 _ssSetOutputPortNumDimensions(childS, 0, 1);
6117 ssSetOutputPortWidth(childS, 0, 1);
6118 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
6119 ssGetLocalBlockIO(rts))->GeneratedSFunction2));
6120 }
6121 }
6122
6123 /* path info */
6124 _ssSetModelName(childS, "LeadLagFilter_sf");
6125 _ssSetPath(childS,
6126 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Lead lag/Generated S-Function2");
6127 if (ssGetRTModel(rts) == (NULL)) {
6128 _ssSetParentSS(childS, rts);
6129 _ssSetRootSS(childS, ssGetRootSS(rts));
6130 } else {
6131 ssSetRTModel(childS,ssGetRTModel(rts));
6132 _ssSetParentSS(childS, (NULL));
6133 _ssSetRootSS(childS, childS);
6134 }
6135
6136 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
6137
6138 /* work vectors */
6139 {
6140 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
6141 (4 * sizeof(struct _ssDWorkRecord));
6142 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
6143 calloc(4, sizeof(struct _ssDWorkAuxRecord));
6144 ss_VALIDATE_MEMORY(rts,dWorkRecord);
6145 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
6146 ssSetSFcnDWork(childS, dWorkRecord);
6147 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
6148 _ssSetNumDWork(childS, 4);
6149
6150 /* DWORK0 */
6151 ssSetDWorkWidth(childS, 0, 1);
6152 ssSetDWorkDataType(childS, 0,SS_SINGLE);
6153 ssSetDWorkComplexSignal(childS, 0, 0);
6154 ssSetDWorkUsedAsDState(childS, 0, 1);
6155 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 164))[0]);
6156
6157 /* DWORK1 */
6158 ssSetDWorkWidth(childS, 1, 1);
6159 ssSetDWorkDataType(childS, 1,SS_SINGLE);
6160 ssSetDWorkComplexSignal(childS, 1, 0);
6161 ssSetDWorkUsedAsDState(childS, 1, 1);
6162 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 165))[0]);
6163
6164 /* DWORK2 */
6165 ssSetDWorkWidth(childS, 2, 1);
6166 ssSetDWorkDataType(childS, 2,SS_INT8);
6167 ssSetDWorkComplexSignal(childS, 2, 0);
6168 ssSetDWorkUsedAsDState(childS, 2, 1);
6169 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 391))[0]);
6170
6171 /* DWORK3 */
6172 ssSetDWorkWidth(childS, 3, 1);
6173 ssSetDWorkDataType(childS, 3,SS_INT8);
6174 ssSetDWorkComplexSignal(childS, 3, 0);
6175 ssSetDWorkUsedAsDState(childS, 3, 1);
6176 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 392))[0]);
6177 }
6178
6179 (childS)->regDataType.arg1 = ((void *)(childS));
6180 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
6181 FcnSetErrorStatus);
6182 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
6183 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
6184 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
6185 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
6186
6187 /* registration */
6188#if defined(MATLAB_MEX_FILE)
6189
6190 {
6191 int_T i;
6192 mxArray *plhs[1];
6193 mxArray *prhs[4];
6194 double *pr;
6195 volatile int_T *intS = (int_T *)&childS;
6196 int_T addrlen = sizeof(SimStruct *);
6197 int_T m = addrlen/sizeof(int_T) + 1;
6198 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
6199 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
6200 pr = mxGetPr(prhs[1]);
6201 for (i = 0; i < m - 1; i++) {
6202 pr[i] = (double)intS[i];
6203 }
6204
6205 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
6206 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
6207 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
6208
6209 /* Reset port dimensions info functions because the S-function
6210 * and accelerator mex-files explicitly set their dimensions,
6211 * i.e., they are not dynamically sized. For this case, the
6212 * mex-file is responsible for the dimensions info memory
6213 * and Simulink should not free it. This is achieved by
6214 * setting the following two methods to NULL.
6215 */
6216 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
6217 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
6218
6219 /*
6220 * Setup function pointers and call mdlInitializeSizes via
6221 * simulink.c
6222 */
6223 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
6224 mxDestroyArray(plhs[0]);
6225 mxDestroyArray(prhs[0]);
6226 mxDestroyArray(prhs[1]);
6227 mxDestroyArray(prhs[2]);
6228 mxDestroyArray(prhs[3]);
6229 }
6230
6231#else
6232
6233 {
6234 LeadLagFilter_sf(childS);
6235 sfcnInitializeSizes(childS);
6236 }
6237
6238#endif
6239
6240 sfcnInitializeSampleTimes(childS);
6241
6242 /* adjust sample time */
6243 ssSetSampleTime(childS, 0, 0.0);
6244 ssSetOffsetTime(childS, 0, 0.0);
6245 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
6246
6247 /* set compiled values of dynamic vector attributes */
6248 ssSetNumNonsampledZCs(childS, 0);
6249
6250 /* Update connectivity flags for each port */
6251 _ssSetInputPortConnected(childS, 0, 1);
6252 _ssSetInputPortConnected(childS, 1, 1);
6253 _ssSetInputPortConnected(childS, 2, 1);
6254 _ssSetInputPortConnected(childS, 3, 1);
6255 _ssSetInputPortConnected(childS, 4, 1);
6256 _ssSetInputPortConnected(childS, 5, 1);
6257 _ssSetInputPortConnected(childS, 6, 1);
6258 _ssSetOutputPortConnected(childS, 0, 1);
6259 _ssSetOutputPortBeingMerged(childS, 0, 0);
6260
6261 /* Update the BufferDstPort flags for each input port */
6262 _ssSetInputPortBufferDstPort(childS, 0, -1);
6263 _ssSetInputPortBufferDstPort(childS, 1, -1);
6264 _ssSetInputPortBufferDstPort(childS, 2, -1);
6265 _ssSetInputPortBufferDstPort(childS, 3, -1);
6266 _ssSetInputPortBufferDstPort(childS, 4, -1);
6267 _ssSetInputPortBufferDstPort(childS, 5, -1);
6268 _ssSetInputPortBufferDstPort(childS, 6, -1);
6269 }
6270
6271 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S94>/Generated S-Function1 (SaturationLimiter_sf) */
6272 {
6273 SimStruct *childS = ssGetSFunction(rts, 23);
6274
6275 /* timing info */
6276 time_T *sfcnPeriod;
6277 time_T *sfcnOffset;
6278 int_T *sfcnTsMap;
6279 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
6280 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
6281 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
6282 ss_VALIDATE_MEMORY(rts,sfcnOffset);
6283 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
6284 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
6285 (void) memset((void*)sfcnPeriod, 0,
6286 sizeof(time_T)*1);
6287 (void) memset((void*)sfcnOffset, 0,
6288 sizeof(time_T)*1);
6289 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
6290 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
6291 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
6292
6293 /* Set up the mdlInfo pointer */
6294# ifdef USE_RTMODEL
6295
6296 {
6297 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
6298 struct _ssBlkInfo2));
6299 ss_VALIDATE_MEMORY(rts,blkInfo2);
6300 ssSetBlkInfo2Ptr(childS, blkInfo2);
6301 }
6302
6303 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
6304
6305# else
6306
6307 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
6308
6309# endif /* USE_RTMODEL */
6310
6311 /* Allocate memory of model methods 2 */
6312 {
6313 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
6314 malloc(sizeof(struct _ssSFcnModelMethods2));
6315 ss_VALIDATE_MEMORY(rts,methods2);
6316 ssSetModelMethods2(childS, methods2);
6317 }
6318
6319 /* Allocate memory of model methods 3 */
6320 {
6321 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
6322 malloc(sizeof(struct _ssSFcnModelMethods3));
6323 ss_VALIDATE_MEMORY(rts,methods3);
6324 ssSetModelMethods3(childS, methods3);
6325 }
6326
6327 /* Allocate memory for states auxilliary information */
6328 {
6329 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
6330 (sizeof(struct _ssStatesInfo2));
6331 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
6332 malloc(sizeof(ssPeriodicStatesInfo));
6333 ss_VALIDATE_MEMORY(rts,statesInfo2);
6334 ssSetStatesInfo2(childS, statesInfo2);
6335 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
6336 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
6337 }
6338
6339 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
6340 RegNumInputPorts);
6341 ssSetRegNumInputPortsFcnArg(childS,childS);
6342
6343 /* inputs */
6344 {
6345 struct _ssPortInputs *inputPortInfo =
6346 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
6347 ss_VALIDATE_MEMORY(rts,inputPortInfo);
6348 _ssSetNumInputPorts(childS, 3);
6349 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
6350
6351 /* port 0 */
6352 {
6353 real32_T const **sfcnUPtrs = (real32_T const **)
6354 malloc(1 * sizeof(real32_T *));
6355 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6356 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6357 ssGetLocalBlockIO(rts))->GeneratedSFunction2;
6358 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
6359 _ssSetInputPortNumDimensions(childS, 0, 1);
6360 ssSetInputPortWidth(childS, 0, 1);
6361 }
6362
6363 /* port 1 */
6364 {
6365 real32_T const **sfcnUPtrs = (real32_T const **)
6366 malloc(1 * sizeof(real32_T *));
6367 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6368 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6369 ssGetLocalBlockIO(rts))->Product1_m;
6370 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
6371 _ssSetInputPortNumDimensions(childS, 1, 1);
6372 ssSetInputPortWidth(childS, 1, 1);
6373 }
6374
6375 /* port 2 */
6376 {
6377 real32_T const **sfcnUPtrs = (real32_T const **)
6378 malloc(1 * sizeof(real32_T *));
6379 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6380 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6381 ssGetLocalBlockIO(rts))->Product_pp;
6382 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
6383 _ssSetInputPortNumDimensions(childS, 2, 1);
6384 ssSetInputPortWidth(childS, 2, 1);
6385 }
6386 }
6387
6388 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
6389 RegNumOutputPorts);
6390 ssSetRegNumOutputPortsFcnArg(childS,childS);
6391
6392 /* outputs */
6393 {
6394 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
6395 calloc(1, sizeof(struct _ssPortOutputs));
6396 ss_VALIDATE_MEMORY(rts,outputPortInfo);
6397 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
6398 _ssSetNumOutputPorts(childS, 1);
6399
6400 /* port 0 */
6401 {
6402 _ssSetOutputPortNumDimensions(childS, 0, 1);
6403 ssSetOutputPortWidth(childS, 0, 1);
6404 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
6405 ssGetLocalBlockIO(rts))->GeneratedSFunction1_b));
6406 }
6407 }
6408
6409 /* path info */
6410 _ssSetModelName(childS, "SaturationLimiter_sf");
6411 _ssSetPath(childS,
6412 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/Saturation Limiter4/Generated S-Function1");
6413 if (ssGetRTModel(rts) == (NULL)) {
6414 _ssSetParentSS(childS, rts);
6415 _ssSetRootSS(childS, ssGetRootSS(rts));
6416 } else {
6417 ssSetRTModel(childS,ssGetRTModel(rts));
6418 _ssSetParentSS(childS, (NULL));
6419 _ssSetRootSS(childS, childS);
6420 }
6421
6422 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
6423 (childS)->regDataType.arg1 = ((void *)(childS));
6424 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
6425 FcnSetErrorStatus);
6426 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
6427 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
6428 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
6429 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
6430
6431 /* registration */
6432#if defined(MATLAB_MEX_FILE)
6433
6434 {
6435 int_T i;
6436 mxArray *plhs[1];
6437 mxArray *prhs[4];
6438 double *pr;
6439 volatile int_T *intS = (int_T *)&childS;
6440 int_T addrlen = sizeof(SimStruct *);
6441 int_T m = addrlen/sizeof(int_T) + 1;
6442 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
6443 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
6444 pr = mxGetPr(prhs[1]);
6445 for (i = 0; i < m - 1; i++) {
6446 pr[i] = (double)intS[i];
6447 }
6448
6449 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
6450 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
6451 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
6452
6453 /* Reset port dimensions info functions because the S-function
6454 * and accelerator mex-files explicitly set their dimensions,
6455 * i.e., they are not dynamically sized. For this case, the
6456 * mex-file is responsible for the dimensions info memory
6457 * and Simulink should not free it. This is achieved by
6458 * setting the following two methods to NULL.
6459 */
6460 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
6461 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
6462
6463 /*
6464 * Setup function pointers and call mdlInitializeSizes via
6465 * simulink.c
6466 */
6467 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
6468 mxDestroyArray(plhs[0]);
6469 mxDestroyArray(prhs[0]);
6470 mxDestroyArray(prhs[1]);
6471 mxDestroyArray(prhs[2]);
6472 mxDestroyArray(prhs[3]);
6473 }
6474
6475#else
6476
6477 {
6478 SaturationLimiter_sf(childS);
6479 sfcnInitializeSizes(childS);
6480 }
6481
6482#endif
6483
6484 sfcnInitializeSampleTimes(childS);
6485
6486 /* adjust sample time */
6487 ssSetSampleTime(childS, 0, 0.0);
6488 ssSetOffsetTime(childS, 0, 0.0);
6489 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
6490
6491 /* set compiled values of dynamic vector attributes */
6492 ssSetNumNonsampledZCs(childS, 0);
6493
6494 /* Update connectivity flags for each port */
6495 _ssSetInputPortConnected(childS, 0, 1);
6496 _ssSetInputPortConnected(childS, 1, 1);
6497 _ssSetInputPortConnected(childS, 2, 1);
6498 _ssSetOutputPortConnected(childS, 0, 1);
6499 _ssSetOutputPortBeingMerged(childS, 0, 0);
6500
6501 /* Update the BufferDstPort flags for each input port */
6502 _ssSetInputPortBufferDstPort(childS, 0, -1);
6503 _ssSetInputPortBufferDstPort(childS, 1, -1);
6504 _ssSetInputPortBufferDstPort(childS, 2, -1);
6505 }
6506
6507 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S87>/Generated S-Function4 (LagFilter_sf) */
6508 {
6509 SimStruct *childS = ssGetSFunction(rts, 24);
6510
6511 /* timing info */
6512 time_T *sfcnPeriod;
6513 time_T *sfcnOffset;
6514 int_T *sfcnTsMap;
6515 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
6516 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
6517 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
6518 ss_VALIDATE_MEMORY(rts,sfcnOffset);
6519 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
6520 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
6521 (void) memset((void*)sfcnPeriod, 0,
6522 sizeof(time_T)*1);
6523 (void) memset((void*)sfcnOffset, 0,
6524 sizeof(time_T)*1);
6525 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
6526 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
6527 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
6528
6529 /* Set up the mdlInfo pointer */
6530# ifdef USE_RTMODEL
6531
6532 {
6533 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
6534 struct _ssBlkInfo2));
6535 ss_VALIDATE_MEMORY(rts,blkInfo2);
6536 ssSetBlkInfo2Ptr(childS, blkInfo2);
6537 }
6538
6539 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
6540
6541# else
6542
6543 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
6544
6545# endif /* USE_RTMODEL */
6546
6547 /* Allocate memory of model methods 2 */
6548 {
6549 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
6550 malloc(sizeof(struct _ssSFcnModelMethods2));
6551 ss_VALIDATE_MEMORY(rts,methods2);
6552 ssSetModelMethods2(childS, methods2);
6553 }
6554
6555 /* Allocate memory of model methods 3 */
6556 {
6557 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
6558 malloc(sizeof(struct _ssSFcnModelMethods3));
6559 ss_VALIDATE_MEMORY(rts,methods3);
6560 ssSetModelMethods3(childS, methods3);
6561 }
6562
6563 /* Allocate memory for states auxilliary information */
6564 {
6565 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
6566 (sizeof(struct _ssStatesInfo2));
6567 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
6568 malloc(sizeof(ssPeriodicStatesInfo));
6569 ss_VALIDATE_MEMORY(rts,statesInfo2);
6570 ssSetStatesInfo2(childS, statesInfo2);
6571 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
6572 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
6573 }
6574
6575 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
6576 RegNumInputPorts);
6577 ssSetRegNumInputPortsFcnArg(childS,childS);
6578
6579 /* inputs */
6580 {
6581 struct _ssPortInputs *inputPortInfo =
6582 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
6583 ss_VALIDATE_MEMORY(rts,inputPortInfo);
6584 _ssSetNumInputPorts(childS, 6);
6585 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
6586
6587 /* port 0 */
6588 {
6589 real32_T const **sfcnUPtrs = (real32_T const **)
6590 malloc(1 * sizeof(real32_T *));
6591 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6592 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6593 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
6594 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
6595 _ssSetInputPortNumDimensions(childS, 0, 1);
6596 ssSetInputPortWidth(childS, 0, 1);
6597 }
6598
6599 /* port 1 */
6600 {
6601 int8_T const **sfcnUPtrs = (int8_T const **)
6602 malloc(1 * sizeof(int8_T *));
6603 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6604 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
6605 ssGetLocalBlockIO(rts))->DataTypeConversion3_c;
6606 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
6607 _ssSetInputPortNumDimensions(childS, 1, 1);
6608 ssSetInputPortWidth(childS, 1, 1);
6609 }
6610
6611 /* port 2 */
6612 {
6613 real32_T const **sfcnUPtrs = (real32_T const **)
6614 malloc(1 * sizeof(real32_T *));
6615 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6616 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
6617 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
6618 _ssSetInputPortNumDimensions(childS, 2, 1);
6619 ssSetInputPortWidth(childS, 2, 1);
6620 }
6621
6622 /* port 3 */
6623 {
6624 real32_T const **sfcnUPtrs = (real32_T const **)
6625 malloc(1 * sizeof(real32_T *));
6626 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6627 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6628 ssGetLocalBlockIO(rts))->Switch_aj;
6629 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
6630 _ssSetInputPortNumDimensions(childS, 3, 1);
6631 ssSetInputPortWidth(childS, 3, 1);
6632 }
6633
6634 /* port 4 */
6635 {
6636 real32_T const **sfcnUPtrs = (real32_T const **)
6637 malloc(1 * sizeof(real32_T *));
6638 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6639 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6640 ssGetLocalBlockIO(rts))->Switch_aj;
6641 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
6642 _ssSetInputPortNumDimensions(childS, 4, 1);
6643 ssSetInputPortWidth(childS, 4, 1);
6644 }
6645
6646 /* port 5 */
6647 {
6648 real32_T const **sfcnUPtrs = (real32_T const **)
6649 malloc(1 * sizeof(real32_T *));
6650 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6651 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6652 ssGetLocalBlockIO(rts))->GeneratedSFunction1_b;
6653 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
6654 _ssSetInputPortNumDimensions(childS, 5, 1);
6655 ssSetInputPortWidth(childS, 5, 1);
6656 }
6657 }
6658
6659 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
6660 RegNumOutputPorts);
6661 ssSetRegNumOutputPortsFcnArg(childS,childS);
6662
6663 /* outputs */
6664 {
6665 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
6666 calloc(1, sizeof(struct _ssPortOutputs));
6667 ss_VALIDATE_MEMORY(rts,outputPortInfo);
6668 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
6669 _ssSetNumOutputPorts(childS, 1);
6670
6671 /* port 0 */
6672 {
6673 _ssSetOutputPortNumDimensions(childS, 0, 1);
6674 ssSetOutputPortWidth(childS, 0, 1);
6675 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
6676 ssGetLocalBlockIO(rts))->GeneratedSFunction4));
6677 }
6678 }
6679
6680 /* path info */
6681 _ssSetModelName(childS, "LagFilter_sf");
6682 _ssSetPath(childS,
6683 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/AltLControl/ lag filter/Generated S-Function4");
6684 if (ssGetRTModel(rts) == (NULL)) {
6685 _ssSetParentSS(childS, rts);
6686 _ssSetRootSS(childS, ssGetRootSS(rts));
6687 } else {
6688 ssSetRTModel(childS,ssGetRTModel(rts));
6689 _ssSetParentSS(childS, (NULL));
6690 _ssSetRootSS(childS, childS);
6691 }
6692
6693 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
6694
6695 /* work vectors */
6696 {
6697 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
6698 (4 * sizeof(struct _ssDWorkRecord));
6699 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
6700 calloc(4, sizeof(struct _ssDWorkAuxRecord));
6701 ss_VALIDATE_MEMORY(rts,dWorkRecord);
6702 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
6703 ssSetSFcnDWork(childS, dWorkRecord);
6704 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
6705 _ssSetNumDWork(childS, 4);
6706
6707 /* DWORK0 */
6708 ssSetDWorkWidth(childS, 0, 1);
6709 ssSetDWorkDataType(childS, 0,SS_SINGLE);
6710 ssSetDWorkComplexSignal(childS, 0, 0);
6711 ssSetDWorkUsedAsDState(childS, 0, 1);
6712 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 166))[0]);
6713
6714 /* DWORK1 */
6715 ssSetDWorkWidth(childS, 1, 1);
6716 ssSetDWorkDataType(childS, 1,SS_SINGLE);
6717 ssSetDWorkComplexSignal(childS, 1, 0);
6718 ssSetDWorkUsedAsDState(childS, 1, 1);
6719 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 167))[0]);
6720
6721 /* DWORK2 */
6722 ssSetDWorkWidth(childS, 2, 1);
6723 ssSetDWorkDataType(childS, 2,SS_INT8);
6724 ssSetDWorkComplexSignal(childS, 2, 0);
6725 ssSetDWorkUsedAsDState(childS, 2, 1);
6726 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 393))[0]);
6727
6728 /* DWORK3 */
6729 ssSetDWorkWidth(childS, 3, 1);
6730 ssSetDWorkDataType(childS, 3,SS_INT8);
6731 ssSetDWorkComplexSignal(childS, 3, 0);
6732 ssSetDWorkUsedAsDState(childS, 3, 1);
6733 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 394))[0]);
6734 }
6735
6736 (childS)->regDataType.arg1 = ((void *)(childS));
6737 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
6738 FcnSetErrorStatus);
6739 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
6740 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
6741 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
6742 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
6743
6744 /* registration */
6745#if defined(MATLAB_MEX_FILE)
6746
6747 {
6748 int_T i;
6749 mxArray *plhs[1];
6750 mxArray *prhs[4];
6751 double *pr;
6752 volatile int_T *intS = (int_T *)&childS;
6753 int_T addrlen = sizeof(SimStruct *);
6754 int_T m = addrlen/sizeof(int_T) + 1;
6755 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
6756 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
6757 pr = mxGetPr(prhs[1]);
6758 for (i = 0; i < m - 1; i++) {
6759 pr[i] = (double)intS[i];
6760 }
6761
6762 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
6763 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
6764 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
6765
6766 /* Reset port dimensions info functions because the S-function
6767 * and accelerator mex-files explicitly set their dimensions,
6768 * i.e., they are not dynamically sized. For this case, the
6769 * mex-file is responsible for the dimensions info memory
6770 * and Simulink should not free it. This is achieved by
6771 * setting the following two methods to NULL.
6772 */
6773 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
6774 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
6775
6776 /*
6777 * Setup function pointers and call mdlInitializeSizes via
6778 * simulink.c
6779 */
6780 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
6781 mxDestroyArray(plhs[0]);
6782 mxDestroyArray(prhs[0]);
6783 mxDestroyArray(prhs[1]);
6784 mxDestroyArray(prhs[2]);
6785 mxDestroyArray(prhs[3]);
6786 }
6787
6788#else
6789
6790 {
6791 LagFilter_sf(childS);
6792 sfcnInitializeSizes(childS);
6793 }
6794
6795#endif
6796
6797 sfcnInitializeSampleTimes(childS);
6798
6799 /* adjust sample time */
6800 ssSetSampleTime(childS, 0, 0.0);
6801 ssSetOffsetTime(childS, 0, 0.0);
6802 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
6803
6804 /* set compiled values of dynamic vector attributes */
6805 ssSetNumNonsampledZCs(childS, 0);
6806
6807 /* Update connectivity flags for each port */
6808 _ssSetInputPortConnected(childS, 0, 1);
6809 _ssSetInputPortConnected(childS, 1, 1);
6810 _ssSetInputPortConnected(childS, 2, 1);
6811 _ssSetInputPortConnected(childS, 3, 1);
6812 _ssSetInputPortConnected(childS, 4, 1);
6813 _ssSetInputPortConnected(childS, 5, 1);
6814 _ssSetOutputPortConnected(childS, 0, 1);
6815 _ssSetOutputPortBeingMerged(childS, 0, 0);
6816
6817 /* Update the BufferDstPort flags for each input port */
6818 _ssSetInputPortBufferDstPort(childS, 0, -1);
6819 _ssSetInputPortBufferDstPort(childS, 1, -1);
6820 _ssSetInputPortBufferDstPort(childS, 2, -1);
6821 _ssSetInputPortBufferDstPort(childS, 3, -1);
6822 _ssSetInputPortBufferDstPort(childS, 4, -1);
6823 _ssSetInputPortBufferDstPort(childS, 5, -1);
6824 }
6825
6826 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S114>/Generated S-Function (SaturationLimiter_sf) */
6827 {
6828 SimStruct *childS = ssGetSFunction(rts, 25);
6829
6830 /* timing info */
6831 time_T *sfcnPeriod;
6832 time_T *sfcnOffset;
6833 int_T *sfcnTsMap;
6834 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
6835 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
6836 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
6837 ss_VALIDATE_MEMORY(rts,sfcnOffset);
6838 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
6839 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
6840 (void) memset((void*)sfcnPeriod, 0,
6841 sizeof(time_T)*1);
6842 (void) memset((void*)sfcnOffset, 0,
6843 sizeof(time_T)*1);
6844 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
6845 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
6846 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
6847
6848 /* Set up the mdlInfo pointer */
6849# ifdef USE_RTMODEL
6850
6851 {
6852 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
6853 struct _ssBlkInfo2));
6854 ss_VALIDATE_MEMORY(rts,blkInfo2);
6855 ssSetBlkInfo2Ptr(childS, blkInfo2);
6856 }
6857
6858 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
6859
6860# else
6861
6862 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
6863
6864# endif /* USE_RTMODEL */
6865
6866 /* Allocate memory of model methods 2 */
6867 {
6868 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
6869 malloc(sizeof(struct _ssSFcnModelMethods2));
6870 ss_VALIDATE_MEMORY(rts,methods2);
6871 ssSetModelMethods2(childS, methods2);
6872 }
6873
6874 /* Allocate memory of model methods 3 */
6875 {
6876 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
6877 malloc(sizeof(struct _ssSFcnModelMethods3));
6878 ss_VALIDATE_MEMORY(rts,methods3);
6879 ssSetModelMethods3(childS, methods3);
6880 }
6881
6882 /* Allocate memory for states auxilliary information */
6883 {
6884 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
6885 (sizeof(struct _ssStatesInfo2));
6886 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
6887 malloc(sizeof(ssPeriodicStatesInfo));
6888 ss_VALIDATE_MEMORY(rts,statesInfo2);
6889 ssSetStatesInfo2(childS, statesInfo2);
6890 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
6891 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
6892 }
6893
6894 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
6895 RegNumInputPorts);
6896 ssSetRegNumInputPortsFcnArg(childS,childS);
6897
6898 /* inputs */
6899 {
6900 struct _ssPortInputs *inputPortInfo =
6901 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
6902 ss_VALIDATE_MEMORY(rts,inputPortInfo);
6903 _ssSetNumInputPorts(childS, 3);
6904 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
6905
6906 /* port 0 */
6907 {
6908 real32_T const **sfcnUPtrs = (real32_T const **)
6909 malloc(1 * sizeof(real32_T *));
6910 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6911 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
6912 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
6913 _ssSetInputPortNumDimensions(childS, 0, 1);
6914 ssSetInputPortWidth(childS, 0, 1);
6915 }
6916
6917 /* port 1 */
6918 {
6919 real32_T const **sfcnUPtrs = (real32_T const **)
6920 malloc(1 * sizeof(real32_T *));
6921 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6922 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6923 ssGetLocalBlockIO(rts))->Product1_m;
6924 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
6925 _ssSetInputPortNumDimensions(childS, 1, 1);
6926 ssSetInputPortWidth(childS, 1, 1);
6927 }
6928
6929 /* port 2 */
6930 {
6931 real32_T const **sfcnUPtrs = (real32_T const **)
6932 malloc(1 * sizeof(real32_T *));
6933 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
6934 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
6935 ssGetLocalBlockIO(rts))->Product_pp;
6936 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
6937 _ssSetInputPortNumDimensions(childS, 2, 1);
6938 ssSetInputPortWidth(childS, 2, 1);
6939 }
6940 }
6941
6942 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
6943 RegNumOutputPorts);
6944 ssSetRegNumOutputPortsFcnArg(childS,childS);
6945
6946 /* outputs */
6947 {
6948 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
6949 calloc(1, sizeof(struct _ssPortOutputs));
6950 ss_VALIDATE_MEMORY(rts,outputPortInfo);
6951 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
6952 _ssSetNumOutputPorts(childS, 1);
6953
6954 /* port 0 */
6955 {
6956 _ssSetOutputPortNumDimensions(childS, 0, 1);
6957 ssSetOutputPortWidth(childS, 0, 1);
6958 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
6959 ssGetLocalBlockIO(rts))->GeneratedSFunction_kz));
6960 }
6961 }
6962
6963 /* path info */
6964 _ssSetModelName(childS, "SaturationLimiter_sf");
6965 _ssSetPath(childS,
6966 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/NzControl/Saturation Limiter1/Generated S-Function");
6967 if (ssGetRTModel(rts) == (NULL)) {
6968 _ssSetParentSS(childS, rts);
6969 _ssSetRootSS(childS, ssGetRootSS(rts));
6970 } else {
6971 ssSetRTModel(childS,ssGetRTModel(rts));
6972 _ssSetParentSS(childS, (NULL));
6973 _ssSetRootSS(childS, childS);
6974 }
6975
6976 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
6977 (childS)->regDataType.arg1 = ((void *)(childS));
6978 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
6979 FcnSetErrorStatus);
6980 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
6981 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
6982 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
6983 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
6984
6985 /* registration */
6986#if defined(MATLAB_MEX_FILE)
6987
6988 {
6989 int_T i;
6990 mxArray *plhs[1];
6991 mxArray *prhs[4];
6992 double *pr;
6993 volatile int_T *intS = (int_T *)&childS;
6994 int_T addrlen = sizeof(SimStruct *);
6995 int_T m = addrlen/sizeof(int_T) + 1;
6996 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
6997 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
6998 pr = mxGetPr(prhs[1]);
6999 for (i = 0; i < m - 1; i++) {
7000 pr[i] = (double)intS[i];
7001 }
7002
7003 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
7004 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
7005 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
7006
7007 /* Reset port dimensions info functions because the S-function
7008 * and accelerator mex-files explicitly set their dimensions,
7009 * i.e., they are not dynamically sized. For this case, the
7010 * mex-file is responsible for the dimensions info memory
7011 * and Simulink should not free it. This is achieved by
7012 * setting the following two methods to NULL.
7013 */
7014 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
7015 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
7016
7017 /*
7018 * Setup function pointers and call mdlInitializeSizes via
7019 * simulink.c
7020 */
7021 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
7022 mxDestroyArray(plhs[0]);
7023 mxDestroyArray(prhs[0]);
7024 mxDestroyArray(prhs[1]);
7025 mxDestroyArray(prhs[2]);
7026 mxDestroyArray(prhs[3]);
7027 }
7028
7029#else
7030
7031 {
7032 SaturationLimiter_sf(childS);
7033 sfcnInitializeSizes(childS);
7034 }
7035
7036#endif
7037
7038 sfcnInitializeSampleTimes(childS);
7039
7040 /* adjust sample time */
7041 ssSetSampleTime(childS, 0, 0.0);
7042 ssSetOffsetTime(childS, 0, 0.0);
7043 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
7044
7045 /* set compiled values of dynamic vector attributes */
7046 ssSetNumNonsampledZCs(childS, 0);
7047
7048 /* Update connectivity flags for each port */
7049 _ssSetInputPortConnected(childS, 0, 1);
7050 _ssSetInputPortConnected(childS, 1, 1);
7051 _ssSetInputPortConnected(childS, 2, 1);
7052 _ssSetOutputPortConnected(childS, 0, 1);
7053 _ssSetOutputPortBeingMerged(childS, 0, 0);
7054
7055 /* Update the BufferDstPort flags for each input port */
7056 _ssSetInputPortBufferDstPort(childS, 0, -1);
7057 _ssSetInputPortBufferDstPort(childS, 1, -1);
7058 _ssSetInputPortBufferDstPort(childS, 2, -1);
7059 }
7060
7061 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S113>/Generated S-Function (LagFilter_sf) */
7062 {
7063 SimStruct *childS = ssGetSFunction(rts, 26);
7064
7065 /* timing info */
7066 time_T *sfcnPeriod;
7067 time_T *sfcnOffset;
7068 int_T *sfcnTsMap;
7069 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
7070 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
7071 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
7072 ss_VALIDATE_MEMORY(rts,sfcnOffset);
7073 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
7074 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
7075 (void) memset((void*)sfcnPeriod, 0,
7076 sizeof(time_T)*1);
7077 (void) memset((void*)sfcnOffset, 0,
7078 sizeof(time_T)*1);
7079 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
7080 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
7081 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
7082
7083 /* Set up the mdlInfo pointer */
7084# ifdef USE_RTMODEL
7085
7086 {
7087 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
7088 struct _ssBlkInfo2));
7089 ss_VALIDATE_MEMORY(rts,blkInfo2);
7090 ssSetBlkInfo2Ptr(childS, blkInfo2);
7091 }
7092
7093 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
7094
7095# else
7096
7097 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
7098
7099# endif /* USE_RTMODEL */
7100
7101 /* Allocate memory of model methods 2 */
7102 {
7103 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
7104 malloc(sizeof(struct _ssSFcnModelMethods2));
7105 ss_VALIDATE_MEMORY(rts,methods2);
7106 ssSetModelMethods2(childS, methods2);
7107 }
7108
7109 /* Allocate memory of model methods 3 */
7110 {
7111 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
7112 malloc(sizeof(struct _ssSFcnModelMethods3));
7113 ss_VALIDATE_MEMORY(rts,methods3);
7114 ssSetModelMethods3(childS, methods3);
7115 }
7116
7117 /* Allocate memory for states auxilliary information */
7118 {
7119 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
7120 (sizeof(struct _ssStatesInfo2));
7121 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
7122 malloc(sizeof(ssPeriodicStatesInfo));
7123 ss_VALIDATE_MEMORY(rts,statesInfo2);
7124 ssSetStatesInfo2(childS, statesInfo2);
7125 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
7126 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
7127 }
7128
7129 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
7130 RegNumInputPorts);
7131 ssSetRegNumInputPortsFcnArg(childS,childS);
7132
7133 /* inputs */
7134 {
7135 struct _ssPortInputs *inputPortInfo =
7136 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
7137 ss_VALIDATE_MEMORY(rts,inputPortInfo);
7138 _ssSetNumInputPorts(childS, 6);
7139 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
7140
7141 /* port 0 */
7142 {
7143 real32_T const **sfcnUPtrs = (real32_T const **)
7144 malloc(1 * sizeof(real32_T *));
7145 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7146 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
7147 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
7148 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
7149 _ssSetInputPortNumDimensions(childS, 0, 1);
7150 ssSetInputPortWidth(childS, 0, 1);
7151 }
7152
7153 /* port 1 */
7154 {
7155 int8_T const **sfcnUPtrs = (int8_T const **)
7156 malloc(1 * sizeof(int8_T *));
7157 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7158 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
7159 ssGetLocalBlockIO(rts))->DataTypeConversion_gv;
7160 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
7161 _ssSetInputPortNumDimensions(childS, 1, 1);
7162 ssSetInputPortWidth(childS, 1, 1);
7163 }
7164
7165 /* port 2 */
7166 {
7167 real32_T const **sfcnUPtrs = (real32_T const **)
7168 malloc(1 * sizeof(real32_T *));
7169 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7170 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
7171 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
7172 _ssSetInputPortNumDimensions(childS, 2, 1);
7173 ssSetInputPortWidth(childS, 2, 1);
7174 }
7175
7176 /* port 3 */
7177 {
7178 real32_T const **sfcnUPtrs = (real32_T const **)
7179 malloc(1 * sizeof(real32_T *));
7180 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7181 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
7182 ssGetLocalBlockIO(rts))->Switch_aj;
7183 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
7184 _ssSetInputPortNumDimensions(childS, 3, 1);
7185 ssSetInputPortWidth(childS, 3, 1);
7186 }
7187
7188 /* port 4 */
7189 {
7190 real32_T const **sfcnUPtrs = (real32_T const **)
7191 malloc(1 * sizeof(real32_T *));
7192 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7193 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
7194 ssGetLocalBlockIO(rts))->Switch_aj;
7195 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
7196 _ssSetInputPortNumDimensions(childS, 4, 1);
7197 ssSetInputPortWidth(childS, 4, 1);
7198 }
7199
7200 /* port 5 */
7201 {
7202 real32_T const **sfcnUPtrs = (real32_T const **)
7203 malloc(1 * sizeof(real32_T *));
7204 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7205 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
7206 ssGetLocalBlockIO(rts))->GeneratedSFunction_kz;
7207 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
7208 _ssSetInputPortNumDimensions(childS, 5, 1);
7209 ssSetInputPortWidth(childS, 5, 1);
7210 }
7211 }
7212
7213 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
7214 RegNumOutputPorts);
7215 ssSetRegNumOutputPortsFcnArg(childS,childS);
7216
7217 /* outputs */
7218 {
7219 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
7220 calloc(1, sizeof(struct _ssPortOutputs));
7221 ss_VALIDATE_MEMORY(rts,outputPortInfo);
7222 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
7223 _ssSetNumOutputPorts(childS, 1);
7224
7225 /* port 0 */
7226 {
7227 _ssSetOutputPortNumDimensions(childS, 0, 1);
7228 ssSetOutputPortWidth(childS, 0, 1);
7229 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
7230 ssGetLocalBlockIO(rts))->GeneratedSFunction_p));
7231 }
7232 }
7233
7234 /* path info */
7235 _ssSetModelName(childS, "LagFilter_sf");
7236 _ssSetPath(childS,
7237 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/NzControl/ lag filter/Generated S-Function");
7238 if (ssGetRTModel(rts) == (NULL)) {
7239 _ssSetParentSS(childS, rts);
7240 _ssSetRootSS(childS, ssGetRootSS(rts));
7241 } else {
7242 ssSetRTModel(childS,ssGetRTModel(rts));
7243 _ssSetParentSS(childS, (NULL));
7244 _ssSetRootSS(childS, childS);
7245 }
7246
7247 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
7248
7249 /* work vectors */
7250 {
7251 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
7252 (4 * sizeof(struct _ssDWorkRecord));
7253 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
7254 calloc(4, sizeof(struct _ssDWorkAuxRecord));
7255 ss_VALIDATE_MEMORY(rts,dWorkRecord);
7256 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
7257 ssSetSFcnDWork(childS, dWorkRecord);
7258 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
7259 _ssSetNumDWork(childS, 4);
7260
7261 /* DWORK0 */
7262 ssSetDWorkWidth(childS, 0, 1);
7263 ssSetDWorkDataType(childS, 0,SS_SINGLE);
7264 ssSetDWorkComplexSignal(childS, 0, 0);
7265 ssSetDWorkUsedAsDState(childS, 0, 1);
7266 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 168))[0]);
7267
7268 /* DWORK1 */
7269 ssSetDWorkWidth(childS, 1, 1);
7270 ssSetDWorkDataType(childS, 1,SS_SINGLE);
7271 ssSetDWorkComplexSignal(childS, 1, 0);
7272 ssSetDWorkUsedAsDState(childS, 1, 1);
7273 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 169))[0]);
7274
7275 /* DWORK2 */
7276 ssSetDWorkWidth(childS, 2, 1);
7277 ssSetDWorkDataType(childS, 2,SS_INT8);
7278 ssSetDWorkComplexSignal(childS, 2, 0);
7279 ssSetDWorkUsedAsDState(childS, 2, 1);
7280 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 395))[0]);
7281
7282 /* DWORK3 */
7283 ssSetDWorkWidth(childS, 3, 1);
7284 ssSetDWorkDataType(childS, 3,SS_INT8);
7285 ssSetDWorkComplexSignal(childS, 3, 0);
7286 ssSetDWorkUsedAsDState(childS, 3, 1);
7287 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 396))[0]);
7288 }
7289
7290 (childS)->regDataType.arg1 = ((void *)(childS));
7291 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
7292 FcnSetErrorStatus);
7293 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
7294 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
7295 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
7296 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
7297
7298 /* registration */
7299#if defined(MATLAB_MEX_FILE)
7300
7301 {
7302 int_T i;
7303 mxArray *plhs[1];
7304 mxArray *prhs[4];
7305 double *pr;
7306 volatile int_T *intS = (int_T *)&childS;
7307 int_T addrlen = sizeof(SimStruct *);
7308 int_T m = addrlen/sizeof(int_T) + 1;
7309 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
7310 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
7311 pr = mxGetPr(prhs[1]);
7312 for (i = 0; i < m - 1; i++) {
7313 pr[i] = (double)intS[i];
7314 }
7315
7316 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
7317 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
7318 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
7319
7320 /* Reset port dimensions info functions because the S-function
7321 * and accelerator mex-files explicitly set their dimensions,
7322 * i.e., they are not dynamically sized. For this case, the
7323 * mex-file is responsible for the dimensions info memory
7324 * and Simulink should not free it. This is achieved by
7325 * setting the following two methods to NULL.
7326 */
7327 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
7328 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
7329
7330 /*
7331 * Setup function pointers and call mdlInitializeSizes via
7332 * simulink.c
7333 */
7334 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
7335 mxDestroyArray(plhs[0]);
7336 mxDestroyArray(prhs[0]);
7337 mxDestroyArray(prhs[1]);
7338 mxDestroyArray(prhs[2]);
7339 mxDestroyArray(prhs[3]);
7340 }
7341
7342#else
7343
7344 {
7345 LagFilter_sf(childS);
7346 sfcnInitializeSizes(childS);
7347 }
7348
7349#endif
7350
7351 sfcnInitializeSampleTimes(childS);
7352
7353 /* adjust sample time */
7354 ssSetSampleTime(childS, 0, 0.0);
7355 ssSetOffsetTime(childS, 0, 0.0);
7356 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
7357
7358 /* set compiled values of dynamic vector attributes */
7359 ssSetNumNonsampledZCs(childS, 0);
7360
7361 /* Update connectivity flags for each port */
7362 _ssSetInputPortConnected(childS, 0, 1);
7363 _ssSetInputPortConnected(childS, 1, 1);
7364 _ssSetInputPortConnected(childS, 2, 1);
7365 _ssSetInputPortConnected(childS, 3, 1);
7366 _ssSetInputPortConnected(childS, 4, 1);
7367 _ssSetInputPortConnected(childS, 5, 1);
7368 _ssSetOutputPortConnected(childS, 0, 1);
7369 _ssSetOutputPortBeingMerged(childS, 0, 0);
7370
7371 /* Update the BufferDstPort flags for each input port */
7372 _ssSetInputPortBufferDstPort(childS, 0, -1);
7373 _ssSetInputPortBufferDstPort(childS, 1, -1);
7374 _ssSetInputPortBufferDstPort(childS, 2, -1);
7375 _ssSetInputPortBufferDstPort(childS, 3, -1);
7376 _ssSetInputPortBufferDstPort(childS, 4, -1);
7377 _ssSetInputPortBufferDstPort(childS, 5, -1);
7378 }
7379
7380 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S86>/Generated S-Function6 (Res180_sf) */
7381 {
7382 SimStruct *childS = ssGetSFunction(rts, 27);
7383
7384 /* timing info */
7385 time_T *sfcnPeriod;
7386 time_T *sfcnOffset;
7387 int_T *sfcnTsMap;
7388 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
7389 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
7390 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
7391 ss_VALIDATE_MEMORY(rts,sfcnOffset);
7392 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
7393 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
7394 (void) memset((void*)sfcnPeriod, 0,
7395 sizeof(time_T)*1);
7396 (void) memset((void*)sfcnOffset, 0,
7397 sizeof(time_T)*1);
7398 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
7399 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
7400 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
7401
7402 /* Set up the mdlInfo pointer */
7403# ifdef USE_RTMODEL
7404
7405 {
7406 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
7407 struct _ssBlkInfo2));
7408 ss_VALIDATE_MEMORY(rts,blkInfo2);
7409 ssSetBlkInfo2Ptr(childS, blkInfo2);
7410 }
7411
7412 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
7413
7414# else
7415
7416 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
7417
7418# endif /* USE_RTMODEL */
7419
7420 /* Allocate memory of model methods 2 */
7421 {
7422 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
7423 malloc(sizeof(struct _ssSFcnModelMethods2));
7424 ss_VALIDATE_MEMORY(rts,methods2);
7425 ssSetModelMethods2(childS, methods2);
7426 }
7427
7428 /* Allocate memory of model methods 3 */
7429 {
7430 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
7431 malloc(sizeof(struct _ssSFcnModelMethods3));
7432 ss_VALIDATE_MEMORY(rts,methods3);
7433 ssSetModelMethods3(childS, methods3);
7434 }
7435
7436 /* Allocate memory for states auxilliary information */
7437 {
7438 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
7439 (sizeof(struct _ssStatesInfo2));
7440 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
7441 malloc(sizeof(ssPeriodicStatesInfo));
7442 ss_VALIDATE_MEMORY(rts,statesInfo2);
7443 ssSetStatesInfo2(childS, statesInfo2);
7444 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
7445 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
7446 }
7447
7448 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
7449 RegNumInputPorts);
7450 ssSetRegNumInputPortsFcnArg(childS,childS);
7451
7452 /* inputs */
7453 {
7454 struct _ssPortInputs *inputPortInfo =
7455 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
7456 ss_VALIDATE_MEMORY(rts,inputPortInfo);
7457 _ssSetNumInputPorts(childS, 1);
7458 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
7459
7460 /* port 0 */
7461 {
7462 real32_T const **sfcnUPtrs = (real32_T const **)
7463 malloc(1 * sizeof(real32_T *));
7464 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7465 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
7466 ssGetLocalBlockIO(rts))->Sum1_f;
7467 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
7468 _ssSetInputPortNumDimensions(childS, 0, 1);
7469 ssSetInputPortWidth(childS, 0, 1);
7470 }
7471 }
7472
7473 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
7474 RegNumOutputPorts);
7475 ssSetRegNumOutputPortsFcnArg(childS,childS);
7476
7477 /* outputs */
7478 {
7479 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
7480 calloc(1, sizeof(struct _ssPortOutputs));
7481 ss_VALIDATE_MEMORY(rts,outputPortInfo);
7482 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
7483 _ssSetNumOutputPorts(childS, 1);
7484
7485 /* port 0 */
7486 {
7487 _ssSetOutputPortNumDimensions(childS, 0, 1);
7488 ssSetOutputPortWidth(childS, 0, 1);
7489 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
7490 ssGetLocalBlockIO(rts))->GeneratedSFunction6));
7491 }
7492 }
7493
7494 /* path info */
7495 _ssSetModelName(childS, "Res180_sf");
7496 _ssSetPath(childS,
7497 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/Generated S-Function6");
7498 if (ssGetRTModel(rts) == (NULL)) {
7499 _ssSetParentSS(childS, rts);
7500 _ssSetRootSS(childS, ssGetRootSS(rts));
7501 } else {
7502 ssSetRTModel(childS,ssGetRTModel(rts));
7503 _ssSetParentSS(childS, (NULL));
7504 _ssSetRootSS(childS, childS);
7505 }
7506
7507 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
7508 (childS)->regDataType.arg1 = ((void *)(childS));
7509 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
7510 FcnSetErrorStatus);
7511 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
7512 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
7513 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
7514 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
7515
7516 /* registration */
7517#if defined(MATLAB_MEX_FILE)
7518
7519 {
7520 int_T i;
7521 mxArray *plhs[1];
7522 mxArray *prhs[4];
7523 double *pr;
7524 volatile int_T *intS = (int_T *)&childS;
7525 int_T addrlen = sizeof(SimStruct *);
7526 int_T m = addrlen/sizeof(int_T) + 1;
7527 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
7528 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
7529 pr = mxGetPr(prhs[1]);
7530 for (i = 0; i < m - 1; i++) {
7531 pr[i] = (double)intS[i];
7532 }
7533
7534 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
7535 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
7536 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
7537
7538 /* Reset port dimensions info functions because the S-function
7539 * and accelerator mex-files explicitly set their dimensions,
7540 * i.e., they are not dynamically sized. For this case, the
7541 * mex-file is responsible for the dimensions info memory
7542 * and Simulink should not free it. This is achieved by
7543 * setting the following two methods to NULL.
7544 */
7545 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
7546 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
7547
7548 /*
7549 * Setup function pointers and call mdlInitializeSizes via
7550 * simulink.c
7551 */
7552 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
7553 mxDestroyArray(plhs[0]);
7554 mxDestroyArray(prhs[0]);
7555 mxDestroyArray(prhs[1]);
7556 mxDestroyArray(prhs[2]);
7557 mxDestroyArray(prhs[3]);
7558 }
7559
7560#else
7561
7562 {
7563 Res180_sf(childS);
7564 sfcnInitializeSizes(childS);
7565 }
7566
7567#endif
7568
7569 sfcnInitializeSampleTimes(childS);
7570
7571 /* adjust sample time */
7572 ssSetSampleTime(childS, 0, 0.0);
7573 ssSetOffsetTime(childS, 0, 0.0);
7574 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
7575
7576 /* set compiled values of dynamic vector attributes */
7577 ssSetNumNonsampledZCs(childS, 0);
7578
7579 /* Update connectivity flags for each port */
7580 _ssSetInputPortConnected(childS, 0, 1);
7581 _ssSetOutputPortConnected(childS, 0, 1);
7582 _ssSetOutputPortBeingMerged(childS, 0, 0);
7583
7584 /* Update the BufferDstPort flags for each input port */
7585 _ssSetInputPortBufferDstPort(childS, 0, -1);
7586 }
7587
7588 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S119>/Generated S-Function (SaturationLimiter_sf) */
7589 {
7590 SimStruct *childS = ssGetSFunction(rts, 28);
7591
7592 /* timing info */
7593 time_T *sfcnPeriod;
7594 time_T *sfcnOffset;
7595 int_T *sfcnTsMap;
7596 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
7597 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
7598 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
7599 ss_VALIDATE_MEMORY(rts,sfcnOffset);
7600 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
7601 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
7602 (void) memset((void*)sfcnPeriod, 0,
7603 sizeof(time_T)*1);
7604 (void) memset((void*)sfcnOffset, 0,
7605 sizeof(time_T)*1);
7606 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
7607 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
7608 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
7609
7610 /* Set up the mdlInfo pointer */
7611# ifdef USE_RTMODEL
7612
7613 {
7614 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
7615 struct _ssBlkInfo2));
7616 ss_VALIDATE_MEMORY(rts,blkInfo2);
7617 ssSetBlkInfo2Ptr(childS, blkInfo2);
7618 }
7619
7620 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
7621
7622# else
7623
7624 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
7625
7626# endif /* USE_RTMODEL */
7627
7628 /* Allocate memory of model methods 2 */
7629 {
7630 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
7631 malloc(sizeof(struct _ssSFcnModelMethods2));
7632 ss_VALIDATE_MEMORY(rts,methods2);
7633 ssSetModelMethods2(childS, methods2);
7634 }
7635
7636 /* Allocate memory of model methods 3 */
7637 {
7638 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
7639 malloc(sizeof(struct _ssSFcnModelMethods3));
7640 ss_VALIDATE_MEMORY(rts,methods3);
7641 ssSetModelMethods3(childS, methods3);
7642 }
7643
7644 /* Allocate memory for states auxilliary information */
7645 {
7646 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
7647 (sizeof(struct _ssStatesInfo2));
7648 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
7649 malloc(sizeof(ssPeriodicStatesInfo));
7650 ss_VALIDATE_MEMORY(rts,statesInfo2);
7651 ssSetStatesInfo2(childS, statesInfo2);
7652 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
7653 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
7654 }
7655
7656 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
7657 RegNumInputPorts);
7658 ssSetRegNumInputPortsFcnArg(childS,childS);
7659
7660 /* inputs */
7661 {
7662 struct _ssPortInputs *inputPortInfo =
7663 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
7664 ss_VALIDATE_MEMORY(rts,inputPortInfo);
7665 _ssSetNumInputPorts(childS, 3);
7666 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
7667
7668 /* port 0 */
7669 {
7670 real32_T const **sfcnUPtrs = (real32_T const **)
7671 malloc(1 * sizeof(real32_T *));
7672 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7673 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
7674 ssGetLocalBlockIO(rts))->GeneratedSFunction6;
7675 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
7676 _ssSetInputPortNumDimensions(childS, 0, 1);
7677 ssSetInputPortWidth(childS, 0, 1);
7678 }
7679
7680 /* port 1 */
7681 {
7682 real32_T const **sfcnUPtrs = (real32_T const **)
7683 malloc(1 * sizeof(real32_T *));
7684 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7685 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
7686 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
7687 _ssSetInputPortNumDimensions(childS, 1, 1);
7688 ssSetInputPortWidth(childS, 1, 1);
7689 }
7690
7691 /* port 2 */
7692 {
7693 real32_T const **sfcnUPtrs = (real32_T const **)
7694 malloc(1 * sizeof(real32_T *));
7695 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7696 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;
7697 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
7698 _ssSetInputPortNumDimensions(childS, 2, 1);
7699 ssSetInputPortWidth(childS, 2, 1);
7700 }
7701 }
7702
7703 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
7704 RegNumOutputPorts);
7705 ssSetRegNumOutputPortsFcnArg(childS,childS);
7706
7707 /* outputs */
7708 {
7709 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
7710 calloc(1, sizeof(struct _ssPortOutputs));
7711 ss_VALIDATE_MEMORY(rts,outputPortInfo);
7712 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
7713 _ssSetNumOutputPorts(childS, 1);
7714
7715 /* port 0 */
7716 {
7717 _ssSetOutputPortNumDimensions(childS, 0, 1);
7718 ssSetOutputPortWidth(childS, 0, 1);
7719 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
7720 ssGetLocalBlockIO(rts))->GeneratedSFunction_n0));
7721 }
7722 }
7723
7724 /* path info */
7725 _ssSetModelName(childS, "SaturationLimiter_sf");
7726 _ssSetPath(childS,
7727 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/Saturation Limiter/Generated S-Function");
7728 if (ssGetRTModel(rts) == (NULL)) {
7729 _ssSetParentSS(childS, rts);
7730 _ssSetRootSS(childS, ssGetRootSS(rts));
7731 } else {
7732 ssSetRTModel(childS,ssGetRTModel(rts));
7733 _ssSetParentSS(childS, (NULL));
7734 _ssSetRootSS(childS, childS);
7735 }
7736
7737 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
7738 (childS)->regDataType.arg1 = ((void *)(childS));
7739 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
7740 FcnSetErrorStatus);
7741 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
7742 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
7743 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
7744 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
7745
7746 /* registration */
7747#if defined(MATLAB_MEX_FILE)
7748
7749 {
7750 int_T i;
7751 mxArray *plhs[1];
7752 mxArray *prhs[4];
7753 double *pr;
7754 volatile int_T *intS = (int_T *)&childS;
7755 int_T addrlen = sizeof(SimStruct *);
7756 int_T m = addrlen/sizeof(int_T) + 1;
7757 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
7758 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
7759 pr = mxGetPr(prhs[1]);
7760 for (i = 0; i < m - 1; i++) {
7761 pr[i] = (double)intS[i];
7762 }
7763
7764 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
7765 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
7766 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
7767
7768 /* Reset port dimensions info functions because the S-function
7769 * and accelerator mex-files explicitly set their dimensions,
7770 * i.e., they are not dynamically sized. For this case, the
7771 * mex-file is responsible for the dimensions info memory
7772 * and Simulink should not free it. This is achieved by
7773 * setting the following two methods to NULL.
7774 */
7775 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
7776 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
7777
7778 /*
7779 * Setup function pointers and call mdlInitializeSizes via
7780 * simulink.c
7781 */
7782 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
7783 mxDestroyArray(plhs[0]);
7784 mxDestroyArray(prhs[0]);
7785 mxDestroyArray(prhs[1]);
7786 mxDestroyArray(prhs[2]);
7787 mxDestroyArray(prhs[3]);
7788 }
7789
7790#else
7791
7792 {
7793 SaturationLimiter_sf(childS);
7794 sfcnInitializeSizes(childS);
7795 }
7796
7797#endif
7798
7799 sfcnInitializeSampleTimes(childS);
7800
7801 /* adjust sample time */
7802 ssSetSampleTime(childS, 0, 0.0);
7803 ssSetOffsetTime(childS, 0, 0.0);
7804 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
7805
7806 /* set compiled values of dynamic vector attributes */
7807 ssSetNumNonsampledZCs(childS, 0);
7808
7809 /* Update connectivity flags for each port */
7810 _ssSetInputPortConnected(childS, 0, 1);
7811 _ssSetInputPortConnected(childS, 1, 1);
7812 _ssSetInputPortConnected(childS, 2, 1);
7813 _ssSetOutputPortConnected(childS, 0, 1);
7814 _ssSetOutputPortBeingMerged(childS, 0, 0);
7815
7816 /* Update the BufferDstPort flags for each input port */
7817 _ssSetInputPortBufferDstPort(childS, 0, -1);
7818 _ssSetInputPortBufferDstPort(childS, 1, -1);
7819 _ssSetInputPortBufferDstPort(childS, 2, -1);
7820 }
7821
7822 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S121>/Generated S-Function (Gain_sf) */
7823 {
7824 SimStruct *childS = ssGetSFunction(rts, 29);
7825
7826 /* timing info */
7827 time_T *sfcnPeriod;
7828 time_T *sfcnOffset;
7829 int_T *sfcnTsMap;
7830 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
7831 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
7832 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
7833 ss_VALIDATE_MEMORY(rts,sfcnOffset);
7834 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
7835 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
7836 (void) memset((void*)sfcnPeriod, 0,
7837 sizeof(time_T)*1);
7838 (void) memset((void*)sfcnOffset, 0,
7839 sizeof(time_T)*1);
7840 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
7841 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
7842 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
7843
7844 /* Set up the mdlInfo pointer */
7845# ifdef USE_RTMODEL
7846
7847 {
7848 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
7849 struct _ssBlkInfo2));
7850 ss_VALIDATE_MEMORY(rts,blkInfo2);
7851 ssSetBlkInfo2Ptr(childS, blkInfo2);
7852 }
7853
7854 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
7855
7856# else
7857
7858 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
7859
7860# endif /* USE_RTMODEL */
7861
7862 /* Allocate memory of model methods 2 */
7863 {
7864 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
7865 malloc(sizeof(struct _ssSFcnModelMethods2));
7866 ss_VALIDATE_MEMORY(rts,methods2);
7867 ssSetModelMethods2(childS, methods2);
7868 }
7869
7870 /* Allocate memory of model methods 3 */
7871 {
7872 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
7873 malloc(sizeof(struct _ssSFcnModelMethods3));
7874 ss_VALIDATE_MEMORY(rts,methods3);
7875 ssSetModelMethods3(childS, methods3);
7876 }
7877
7878 /* Allocate memory for states auxilliary information */
7879 {
7880 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
7881 (sizeof(struct _ssStatesInfo2));
7882 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
7883 malloc(sizeof(ssPeriodicStatesInfo));
7884 ss_VALIDATE_MEMORY(rts,statesInfo2);
7885 ssSetStatesInfo2(childS, statesInfo2);
7886 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
7887 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
7888 }
7889
7890 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
7891 RegNumInputPorts);
7892 ssSetRegNumInputPortsFcnArg(childS,childS);
7893
7894 /* inputs */
7895 {
7896 struct _ssPortInputs *inputPortInfo =
7897 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
7898 ss_VALIDATE_MEMORY(rts,inputPortInfo);
7899 _ssSetNumInputPorts(childS, 2);
7900 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
7901
7902 /* port 0 */
7903 {
7904 real32_T const **sfcnUPtrs = (real32_T const **)
7905 malloc(1 * sizeof(real32_T *));
7906 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7907 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
7908 ssGetLocalBlockIO(rts))->GeneratedSFunction_n0;
7909 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
7910 _ssSetInputPortNumDimensions(childS, 0, 1);
7911 ssSetInputPortWidth(childS, 0, 1);
7912 }
7913
7914 /* port 1 */
7915 {
7916 real32_T const **sfcnUPtrs = (real32_T const **)
7917 malloc(1 * sizeof(real32_T *));
7918 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
7919 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;
7920 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
7921 _ssSetInputPortNumDimensions(childS, 1, 1);
7922 ssSetInputPortWidth(childS, 1, 1);
7923 }
7924 }
7925
7926 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
7927 RegNumOutputPorts);
7928 ssSetRegNumOutputPortsFcnArg(childS,childS);
7929
7930 /* outputs */
7931 {
7932 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
7933 calloc(1, sizeof(struct _ssPortOutputs));
7934 ss_VALIDATE_MEMORY(rts,outputPortInfo);
7935 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
7936 _ssSetNumOutputPorts(childS, 1);
7937
7938 /* port 0 */
7939 {
7940 _ssSetOutputPortNumDimensions(childS, 0, 1);
7941 ssSetOutputPortWidth(childS, 0, 1);
7942 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
7943 ssGetLocalBlockIO(rts))->GeneratedSFunction_k1));
7944 }
7945 }
7946
7947 /* path info */
7948 _ssSetModelName(childS, "Gain_sf");
7949 _ssSetPath(childS,
7950 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/gain/Generated S-Function");
7951 if (ssGetRTModel(rts) == (NULL)) {
7952 _ssSetParentSS(childS, rts);
7953 _ssSetRootSS(childS, ssGetRootSS(rts));
7954 } else {
7955 ssSetRTModel(childS,ssGetRTModel(rts));
7956 _ssSetParentSS(childS, (NULL));
7957 _ssSetRootSS(childS, childS);
7958 }
7959
7960 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
7961 (childS)->regDataType.arg1 = ((void *)(childS));
7962 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
7963 FcnSetErrorStatus);
7964 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
7965 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
7966 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
7967 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
7968
7969 /* registration */
7970#if defined(MATLAB_MEX_FILE)
7971
7972 {
7973 int_T i;
7974 mxArray *plhs[1];
7975 mxArray *prhs[4];
7976 double *pr;
7977 volatile int_T *intS = (int_T *)&childS;
7978 int_T addrlen = sizeof(SimStruct *);
7979 int_T m = addrlen/sizeof(int_T) + 1;
7980 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
7981 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
7982 pr = mxGetPr(prhs[1]);
7983 for (i = 0; i < m - 1; i++) {
7984 pr[i] = (double)intS[i];
7985 }
7986
7987 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
7988 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
7989 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
7990
7991 /* Reset port dimensions info functions because the S-function
7992 * and accelerator mex-files explicitly set their dimensions,
7993 * i.e., they are not dynamically sized. For this case, the
7994 * mex-file is responsible for the dimensions info memory
7995 * and Simulink should not free it. This is achieved by
7996 * setting the following two methods to NULL.
7997 */
7998 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
7999 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
8000
8001 /*
8002 * Setup function pointers and call mdlInitializeSizes via
8003 * simulink.c
8004 */
8005 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
8006 mxDestroyArray(plhs[0]);
8007 mxDestroyArray(prhs[0]);
8008 mxDestroyArray(prhs[1]);
8009 mxDestroyArray(prhs[2]);
8010 mxDestroyArray(prhs[3]);
8011 }
8012
8013#else
8014
8015 {
8016 Gain_sf(childS);
8017 sfcnInitializeSizes(childS);
8018 }
8019
8020#endif
8021
8022 sfcnInitializeSampleTimes(childS);
8023
8024 /* adjust sample time */
8025 ssSetSampleTime(childS, 0, 0.0);
8026 ssSetOffsetTime(childS, 0, 0.0);
8027 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
8028
8029 /* set compiled values of dynamic vector attributes */
8030 ssSetNumNonsampledZCs(childS, 0);
8031
8032 /* Update connectivity flags for each port */
8033 _ssSetInputPortConnected(childS, 0, 1);
8034 _ssSetInputPortConnected(childS, 1, 1);
8035 _ssSetOutputPortConnected(childS, 0, 1);
8036 _ssSetOutputPortBeingMerged(childS, 0, 0);
8037
8038 /* Update the BufferDstPort flags for each input port */
8039 _ssSetInputPortBufferDstPort(childS, 0, -1);
8040 _ssSetInputPortBufferDstPort(childS, 1, -1);
8041 }
8042
8043 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S118>/Generated S-Function2 (LeadLagFilter_sf) */
8044 {
8045 SimStruct *childS = ssGetSFunction(rts, 30);
8046
8047 /* timing info */
8048 time_T *sfcnPeriod;
8049 time_T *sfcnOffset;
8050 int_T *sfcnTsMap;
8051 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
8052 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
8053 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
8054 ss_VALIDATE_MEMORY(rts,sfcnOffset);
8055 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
8056 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
8057 (void) memset((void*)sfcnPeriod, 0,
8058 sizeof(time_T)*1);
8059 (void) memset((void*)sfcnOffset, 0,
8060 sizeof(time_T)*1);
8061 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
8062 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
8063 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
8064
8065 /* Set up the mdlInfo pointer */
8066# ifdef USE_RTMODEL
8067
8068 {
8069 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
8070 struct _ssBlkInfo2));
8071 ss_VALIDATE_MEMORY(rts,blkInfo2);
8072 ssSetBlkInfo2Ptr(childS, blkInfo2);
8073 }
8074
8075 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
8076
8077# else
8078
8079 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
8080
8081# endif /* USE_RTMODEL */
8082
8083 /* Allocate memory of model methods 2 */
8084 {
8085 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
8086 malloc(sizeof(struct _ssSFcnModelMethods2));
8087 ss_VALIDATE_MEMORY(rts,methods2);
8088 ssSetModelMethods2(childS, methods2);
8089 }
8090
8091 /* Allocate memory of model methods 3 */
8092 {
8093 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
8094 malloc(sizeof(struct _ssSFcnModelMethods3));
8095 ss_VALIDATE_MEMORY(rts,methods3);
8096 ssSetModelMethods3(childS, methods3);
8097 }
8098
8099 /* Allocate memory for states auxilliary information */
8100 {
8101 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
8102 (sizeof(struct _ssStatesInfo2));
8103 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
8104 malloc(sizeof(ssPeriodicStatesInfo));
8105 ss_VALIDATE_MEMORY(rts,statesInfo2);
8106 ssSetStatesInfo2(childS, statesInfo2);
8107 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
8108 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
8109 }
8110
8111 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
8112 RegNumInputPorts);
8113 ssSetRegNumInputPortsFcnArg(childS,childS);
8114
8115 /* inputs */
8116 {
8117 struct _ssPortInputs *inputPortInfo =
8118 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
8119 ss_VALIDATE_MEMORY(rts,inputPortInfo);
8120 _ssSetNumInputPorts(childS, 7);
8121 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
8122
8123 /* port 0 */
8124 {
8125 real32_T const **sfcnUPtrs = (real32_T const **)
8126 malloc(1 * sizeof(real32_T *));
8127 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8128 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8129 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
8130 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
8131 _ssSetInputPortNumDimensions(childS, 0, 1);
8132 ssSetInputPortWidth(childS, 0, 1);
8133 }
8134
8135 /* port 1 */
8136 {
8137 int8_T const **sfcnUPtrs = (int8_T const **)
8138 malloc(1 * sizeof(int8_T *));
8139 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8140 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
8141 ssGetLocalBlockIO(rts))->DataTypeConversion1_p;
8142 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
8143 _ssSetInputPortNumDimensions(childS, 1, 1);
8144 ssSetInputPortWidth(childS, 1, 1);
8145 }
8146
8147 /* port 2 */
8148 {
8149 real32_T const **sfcnUPtrs = (real32_T const **)
8150 malloc(1 * sizeof(real32_T *));
8151 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8152 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
8153 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
8154 _ssSetInputPortNumDimensions(childS, 2, 1);
8155 ssSetInputPortWidth(childS, 2, 1);
8156 }
8157
8158 /* port 3 */
8159 {
8160 real32_T const **sfcnUPtrs = (real32_T const **)
8161 malloc(1 * sizeof(real32_T *));
8162 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8163 sfcnUPtrs[0] = (real32_T const *)
8164 &AFCS_MODEL1_ConstP.Constant10_Value_a;
8165 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
8166 _ssSetInputPortNumDimensions(childS, 3, 1);
8167 ssSetInputPortWidth(childS, 3, 1);
8168 }
8169
8170 /* port 4 */
8171 {
8172 real32_T const **sfcnUPtrs = (real32_T const **)
8173 malloc(1 * sizeof(real32_T *));
8174 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8175 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8176 ssGetLocalBlockIO(rts))->Switch_aj;
8177 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
8178 _ssSetInputPortNumDimensions(childS, 4, 1);
8179 ssSetInputPortWidth(childS, 4, 1);
8180 }
8181
8182 /* port 5 */
8183 {
8184 real32_T const **sfcnUPtrs = (real32_T const **)
8185 malloc(1 * sizeof(real32_T *));
8186 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8187 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8188 ssGetLocalBlockIO(rts))->Switch_aj;
8189 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
8190 _ssSetInputPortNumDimensions(childS, 5, 1);
8191 ssSetInputPortWidth(childS, 5, 1);
8192 }
8193
8194 /* port 6 */
8195 {
8196 real32_T const **sfcnUPtrs = (real32_T const **)
8197 malloc(1 * sizeof(real32_T *));
8198 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8199 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8200 ssGetLocalBlockIO(rts))->GeneratedSFunction_k1;
8201 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
8202 _ssSetInputPortNumDimensions(childS, 6, 1);
8203 ssSetInputPortWidth(childS, 6, 1);
8204 }
8205 }
8206
8207 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
8208 RegNumOutputPorts);
8209 ssSetRegNumOutputPortsFcnArg(childS,childS);
8210
8211 /* outputs */
8212 {
8213 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
8214 calloc(1, sizeof(struct _ssPortOutputs));
8215 ss_VALIDATE_MEMORY(rts,outputPortInfo);
8216 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
8217 _ssSetNumOutputPorts(childS, 1);
8218
8219 /* port 0 */
8220 {
8221 _ssSetOutputPortNumDimensions(childS, 0, 1);
8222 ssSetOutputPortWidth(childS, 0, 1);
8223 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
8224 ssGetLocalBlockIO(rts))->GeneratedSFunction2_m));
8225 }
8226 }
8227
8228 /* path info */
8229 _ssSetModelName(childS, "LeadLagFilter_sf");
8230 _ssSetPath(childS,
8231 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/Lead lag/Generated S-Function2");
8232 if (ssGetRTModel(rts) == (NULL)) {
8233 _ssSetParentSS(childS, rts);
8234 _ssSetRootSS(childS, ssGetRootSS(rts));
8235 } else {
8236 ssSetRTModel(childS,ssGetRTModel(rts));
8237 _ssSetParentSS(childS, (NULL));
8238 _ssSetRootSS(childS, childS);
8239 }
8240
8241 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
8242
8243 /* work vectors */
8244 {
8245 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
8246 (4 * sizeof(struct _ssDWorkRecord));
8247 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
8248 calloc(4, sizeof(struct _ssDWorkAuxRecord));
8249 ss_VALIDATE_MEMORY(rts,dWorkRecord);
8250 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
8251 ssSetSFcnDWork(childS, dWorkRecord);
8252 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
8253 _ssSetNumDWork(childS, 4);
8254
8255 /* DWORK0 */
8256 ssSetDWorkWidth(childS, 0, 1);
8257 ssSetDWorkDataType(childS, 0,SS_SINGLE);
8258 ssSetDWorkComplexSignal(childS, 0, 0);
8259 ssSetDWorkUsedAsDState(childS, 0, 1);
8260 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 170))[0]);
8261
8262 /* DWORK1 */
8263 ssSetDWorkWidth(childS, 1, 1);
8264 ssSetDWorkDataType(childS, 1,SS_SINGLE);
8265 ssSetDWorkComplexSignal(childS, 1, 0);
8266 ssSetDWorkUsedAsDState(childS, 1, 1);
8267 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 171))[0]);
8268
8269 /* DWORK2 */
8270 ssSetDWorkWidth(childS, 2, 1);
8271 ssSetDWorkDataType(childS, 2,SS_INT8);
8272 ssSetDWorkComplexSignal(childS, 2, 0);
8273 ssSetDWorkUsedAsDState(childS, 2, 1);
8274 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 397))[0]);
8275
8276 /* DWORK3 */
8277 ssSetDWorkWidth(childS, 3, 1);
8278 ssSetDWorkDataType(childS, 3,SS_INT8);
8279 ssSetDWorkComplexSignal(childS, 3, 0);
8280 ssSetDWorkUsedAsDState(childS, 3, 1);
8281 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 398))[0]);
8282 }
8283
8284 (childS)->regDataType.arg1 = ((void *)(childS));
8285 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
8286 FcnSetErrorStatus);
8287 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
8288 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
8289 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
8290 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
8291
8292 /* registration */
8293#if defined(MATLAB_MEX_FILE)
8294
8295 {
8296 int_T i;
8297 mxArray *plhs[1];
8298 mxArray *prhs[4];
8299 double *pr;
8300 volatile int_T *intS = (int_T *)&childS;
8301 int_T addrlen = sizeof(SimStruct *);
8302 int_T m = addrlen/sizeof(int_T) + 1;
8303 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
8304 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
8305 pr = mxGetPr(prhs[1]);
8306 for (i = 0; i < m - 1; i++) {
8307 pr[i] = (double)intS[i];
8308 }
8309
8310 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
8311 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
8312 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
8313
8314 /* Reset port dimensions info functions because the S-function
8315 * and accelerator mex-files explicitly set their dimensions,
8316 * i.e., they are not dynamically sized. For this case, the
8317 * mex-file is responsible for the dimensions info memory
8318 * and Simulink should not free it. This is achieved by
8319 * setting the following two methods to NULL.
8320 */
8321 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
8322 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
8323
8324 /*
8325 * Setup function pointers and call mdlInitializeSizes via
8326 * simulink.c
8327 */
8328 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
8329 mxDestroyArray(plhs[0]);
8330 mxDestroyArray(prhs[0]);
8331 mxDestroyArray(prhs[1]);
8332 mxDestroyArray(prhs[2]);
8333 mxDestroyArray(prhs[3]);
8334 }
8335
8336#else
8337
8338 {
8339 LeadLagFilter_sf(childS);
8340 sfcnInitializeSizes(childS);
8341 }
8342
8343#endif
8344
8345 sfcnInitializeSampleTimes(childS);
8346
8347 /* adjust sample time */
8348 ssSetSampleTime(childS, 0, 0.0);
8349 ssSetOffsetTime(childS, 0, 0.0);
8350 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
8351
8352 /* set compiled values of dynamic vector attributes */
8353 ssSetNumNonsampledZCs(childS, 0);
8354
8355 /* Update connectivity flags for each port */
8356 _ssSetInputPortConnected(childS, 0, 1);
8357 _ssSetInputPortConnected(childS, 1, 1);
8358 _ssSetInputPortConnected(childS, 2, 1);
8359 _ssSetInputPortConnected(childS, 3, 1);
8360 _ssSetInputPortConnected(childS, 4, 1);
8361 _ssSetInputPortConnected(childS, 5, 1);
8362 _ssSetInputPortConnected(childS, 6, 1);
8363 _ssSetOutputPortConnected(childS, 0, 1);
8364 _ssSetOutputPortBeingMerged(childS, 0, 0);
8365
8366 /* Update the BufferDstPort flags for each input port */
8367 _ssSetInputPortBufferDstPort(childS, 0, -1);
8368 _ssSetInputPortBufferDstPort(childS, 1, -1);
8369 _ssSetInputPortBufferDstPort(childS, 2, -1);
8370 _ssSetInputPortBufferDstPort(childS, 3, -1);
8371 _ssSetInputPortBufferDstPort(childS, 4, -1);
8372 _ssSetInputPortBufferDstPort(childS, 5, -1);
8373 _ssSetInputPortBufferDstPort(childS, 6, -1);
8374 }
8375
8376 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S120>/Generated S-Function1 (SaturationLimiter_sf) */
8377 {
8378 SimStruct *childS = ssGetSFunction(rts, 31);
8379
8380 /* timing info */
8381 time_T *sfcnPeriod;
8382 time_T *sfcnOffset;
8383 int_T *sfcnTsMap;
8384 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
8385 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
8386 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
8387 ss_VALIDATE_MEMORY(rts,sfcnOffset);
8388 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
8389 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
8390 (void) memset((void*)sfcnPeriod, 0,
8391 sizeof(time_T)*1);
8392 (void) memset((void*)sfcnOffset, 0,
8393 sizeof(time_T)*1);
8394 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
8395 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
8396 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
8397
8398 /* Set up the mdlInfo pointer */
8399# ifdef USE_RTMODEL
8400
8401 {
8402 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
8403 struct _ssBlkInfo2));
8404 ss_VALIDATE_MEMORY(rts,blkInfo2);
8405 ssSetBlkInfo2Ptr(childS, blkInfo2);
8406 }
8407
8408 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
8409
8410# else
8411
8412 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
8413
8414# endif /* USE_RTMODEL */
8415
8416 /* Allocate memory of model methods 2 */
8417 {
8418 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
8419 malloc(sizeof(struct _ssSFcnModelMethods2));
8420 ss_VALIDATE_MEMORY(rts,methods2);
8421 ssSetModelMethods2(childS, methods2);
8422 }
8423
8424 /* Allocate memory of model methods 3 */
8425 {
8426 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
8427 malloc(sizeof(struct _ssSFcnModelMethods3));
8428 ss_VALIDATE_MEMORY(rts,methods3);
8429 ssSetModelMethods3(childS, methods3);
8430 }
8431
8432 /* Allocate memory for states auxilliary information */
8433 {
8434 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
8435 (sizeof(struct _ssStatesInfo2));
8436 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
8437 malloc(sizeof(ssPeriodicStatesInfo));
8438 ss_VALIDATE_MEMORY(rts,statesInfo2);
8439 ssSetStatesInfo2(childS, statesInfo2);
8440 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
8441 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
8442 }
8443
8444 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
8445 RegNumInputPorts);
8446 ssSetRegNumInputPortsFcnArg(childS,childS);
8447
8448 /* inputs */
8449 {
8450 struct _ssPortInputs *inputPortInfo =
8451 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
8452 ss_VALIDATE_MEMORY(rts,inputPortInfo);
8453 _ssSetNumInputPorts(childS, 3);
8454 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
8455
8456 /* port 0 */
8457 {
8458 real32_T const **sfcnUPtrs = (real32_T const **)
8459 malloc(1 * sizeof(real32_T *));
8460 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8461 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8462 ssGetLocalBlockIO(rts))->GeneratedSFunction2_m;
8463 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
8464 _ssSetInputPortNumDimensions(childS, 0, 1);
8465 ssSetInputPortWidth(childS, 0, 1);
8466 }
8467
8468 /* port 1 */
8469 {
8470 real32_T const **sfcnUPtrs = (real32_T const **)
8471 malloc(1 * sizeof(real32_T *));
8472 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8473 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8474 ssGetLocalBlockIO(rts))->Product1_m;
8475 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
8476 _ssSetInputPortNumDimensions(childS, 1, 1);
8477 ssSetInputPortWidth(childS, 1, 1);
8478 }
8479
8480 /* port 2 */
8481 {
8482 real32_T const **sfcnUPtrs = (real32_T const **)
8483 malloc(1 * sizeof(real32_T *));
8484 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8485 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8486 ssGetLocalBlockIO(rts))->Product_pp;
8487 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
8488 _ssSetInputPortNumDimensions(childS, 2, 1);
8489 ssSetInputPortWidth(childS, 2, 1);
8490 }
8491 }
8492
8493 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
8494 RegNumOutputPorts);
8495 ssSetRegNumOutputPortsFcnArg(childS,childS);
8496
8497 /* outputs */
8498 {
8499 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
8500 calloc(1, sizeof(struct _ssPortOutputs));
8501 ss_VALIDATE_MEMORY(rts,outputPortInfo);
8502 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
8503 _ssSetNumOutputPorts(childS, 1);
8504
8505 /* port 0 */
8506 {
8507 _ssSetOutputPortNumDimensions(childS, 0, 1);
8508 ssSetOutputPortWidth(childS, 0, 1);
8509 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
8510 ssGetLocalBlockIO(rts))->Saturation8));
8511 }
8512 }
8513
8514 /* path info */
8515 _ssSetModelName(childS, "SaturationLimiter_sf");
8516 _ssSetPath(childS,
8517 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/Saturation Limiter1/Generated S-Function1");
8518 if (ssGetRTModel(rts) == (NULL)) {
8519 _ssSetParentSS(childS, rts);
8520 _ssSetRootSS(childS, ssGetRootSS(rts));
8521 } else {
8522 ssSetRTModel(childS,ssGetRTModel(rts));
8523 _ssSetParentSS(childS, (NULL));
8524 _ssSetRootSS(childS, childS);
8525 }
8526
8527 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
8528 (childS)->regDataType.arg1 = ((void *)(childS));
8529 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
8530 FcnSetErrorStatus);
8531 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
8532 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
8533 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
8534 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
8535
8536 /* registration */
8537#if defined(MATLAB_MEX_FILE)
8538
8539 {
8540 int_T i;
8541 mxArray *plhs[1];
8542 mxArray *prhs[4];
8543 double *pr;
8544 volatile int_T *intS = (int_T *)&childS;
8545 int_T addrlen = sizeof(SimStruct *);
8546 int_T m = addrlen/sizeof(int_T) + 1;
8547 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
8548 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
8549 pr = mxGetPr(prhs[1]);
8550 for (i = 0; i < m - 1; i++) {
8551 pr[i] = (double)intS[i];
8552 }
8553
8554 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
8555 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
8556 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
8557
8558 /* Reset port dimensions info functions because the S-function
8559 * and accelerator mex-files explicitly set their dimensions,
8560 * i.e., they are not dynamically sized. For this case, the
8561 * mex-file is responsible for the dimensions info memory
8562 * and Simulink should not free it. This is achieved by
8563 * setting the following two methods to NULL.
8564 */
8565 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
8566 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
8567
8568 /*
8569 * Setup function pointers and call mdlInitializeSizes via
8570 * simulink.c
8571 */
8572 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
8573 mxDestroyArray(plhs[0]);
8574 mxDestroyArray(prhs[0]);
8575 mxDestroyArray(prhs[1]);
8576 mxDestroyArray(prhs[2]);
8577 mxDestroyArray(prhs[3]);
8578 }
8579
8580#else
8581
8582 {
8583 SaturationLimiter_sf(childS);
8584 sfcnInitializeSizes(childS);
8585 }
8586
8587#endif
8588
8589 sfcnInitializeSampleTimes(childS);
8590
8591 /* adjust sample time */
8592 ssSetSampleTime(childS, 0, 0.0);
8593 ssSetOffsetTime(childS, 0, 0.0);
8594 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
8595
8596 /* set compiled values of dynamic vector attributes */
8597 ssSetNumNonsampledZCs(childS, 0);
8598
8599 /* Update connectivity flags for each port */
8600 _ssSetInputPortConnected(childS, 0, 1);
8601 _ssSetInputPortConnected(childS, 1, 1);
8602 _ssSetInputPortConnected(childS, 2, 1);
8603 _ssSetOutputPortConnected(childS, 0, 1);
8604 _ssSetOutputPortBeingMerged(childS, 0, 0);
8605
8606 /* Update the BufferDstPort flags for each input port */
8607 _ssSetInputPortBufferDstPort(childS, 0, -1);
8608 _ssSetInputPortBufferDstPort(childS, 1, -1);
8609 _ssSetInputPortBufferDstPort(childS, 2, -1);
8610 }
8611
8612 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S117>/Generated S-Function4 (LagFilter_sf) */
8613 {
8614 SimStruct *childS = ssGetSFunction(rts, 32);
8615
8616 /* timing info */
8617 time_T *sfcnPeriod;
8618 time_T *sfcnOffset;
8619 int_T *sfcnTsMap;
8620 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
8621 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
8622 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
8623 ss_VALIDATE_MEMORY(rts,sfcnOffset);
8624 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
8625 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
8626 (void) memset((void*)sfcnPeriod, 0,
8627 sizeof(time_T)*1);
8628 (void) memset((void*)sfcnOffset, 0,
8629 sizeof(time_T)*1);
8630 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
8631 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
8632 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
8633
8634 /* Set up the mdlInfo pointer */
8635# ifdef USE_RTMODEL
8636
8637 {
8638 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
8639 struct _ssBlkInfo2));
8640 ss_VALIDATE_MEMORY(rts,blkInfo2);
8641 ssSetBlkInfo2Ptr(childS, blkInfo2);
8642 }
8643
8644 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
8645
8646# else
8647
8648 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
8649
8650# endif /* USE_RTMODEL */
8651
8652 /* Allocate memory of model methods 2 */
8653 {
8654 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
8655 malloc(sizeof(struct _ssSFcnModelMethods2));
8656 ss_VALIDATE_MEMORY(rts,methods2);
8657 ssSetModelMethods2(childS, methods2);
8658 }
8659
8660 /* Allocate memory of model methods 3 */
8661 {
8662 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
8663 malloc(sizeof(struct _ssSFcnModelMethods3));
8664 ss_VALIDATE_MEMORY(rts,methods3);
8665 ssSetModelMethods3(childS, methods3);
8666 }
8667
8668 /* Allocate memory for states auxilliary information */
8669 {
8670 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
8671 (sizeof(struct _ssStatesInfo2));
8672 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
8673 malloc(sizeof(ssPeriodicStatesInfo));
8674 ss_VALIDATE_MEMORY(rts,statesInfo2);
8675 ssSetStatesInfo2(childS, statesInfo2);
8676 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
8677 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
8678 }
8679
8680 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
8681 RegNumInputPorts);
8682 ssSetRegNumInputPortsFcnArg(childS,childS);
8683
8684 /* inputs */
8685 {
8686 struct _ssPortInputs *inputPortInfo =
8687 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
8688 ss_VALIDATE_MEMORY(rts,inputPortInfo);
8689 _ssSetNumInputPorts(childS, 6);
8690 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
8691
8692 /* port 0 */
8693 {
8694 real32_T const **sfcnUPtrs = (real32_T const **)
8695 malloc(1 * sizeof(real32_T *));
8696 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8697 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8698 ssGetLocalBlockIO(rts))->dtCAS;
8699 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
8700 _ssSetInputPortNumDimensions(childS, 0, 1);
8701 ssSetInputPortWidth(childS, 0, 1);
8702 }
8703
8704 /* port 1 */
8705 {
8706 int8_T const **sfcnUPtrs = (int8_T const **)
8707 malloc(1 * sizeof(int8_T *));
8708 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8709 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
8710 ssGetLocalBlockIO(rts))->DataTypeConversion1_p;
8711 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
8712 _ssSetInputPortNumDimensions(childS, 1, 1);
8713 ssSetInputPortWidth(childS, 1, 1);
8714 }
8715
8716 /* port 2 */
8717 {
8718 real32_T const **sfcnUPtrs = (real32_T const **)
8719 malloc(1 * sizeof(real32_T *));
8720 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8721 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
8722 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
8723 _ssSetInputPortNumDimensions(childS, 2, 1);
8724 ssSetInputPortWidth(childS, 2, 1);
8725 }
8726
8727 /* port 3 */
8728 {
8729 real32_T const **sfcnUPtrs = (real32_T const **)
8730 malloc(1 * sizeof(real32_T *));
8731 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8732 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8733 ssGetLocalBlockIO(rts))->Sum1_e;
8734 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
8735 _ssSetInputPortNumDimensions(childS, 3, 1);
8736 ssSetInputPortWidth(childS, 3, 1);
8737 }
8738
8739 /* port 4 */
8740 {
8741 real32_T const **sfcnUPtrs = (real32_T const **)
8742 malloc(1 * sizeof(real32_T *));
8743 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8744 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8745 ssGetLocalBlockIO(rts))->Sum1_e;
8746 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
8747 _ssSetInputPortNumDimensions(childS, 4, 1);
8748 ssSetInputPortWidth(childS, 4, 1);
8749 }
8750
8751 /* port 5 */
8752 {
8753 real32_T const **sfcnUPtrs = (real32_T const **)
8754 malloc(1 * sizeof(real32_T *));
8755 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
8756 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
8757 ssGetLocalBlockIO(rts))->Sum2_eb;
8758 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
8759 _ssSetInputPortNumDimensions(childS, 5, 1);
8760 ssSetInputPortWidth(childS, 5, 1);
8761 }
8762 }
8763
8764 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
8765 RegNumOutputPorts);
8766 ssSetRegNumOutputPortsFcnArg(childS,childS);
8767
8768 /* outputs */
8769 {
8770 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
8771 calloc(1, sizeof(struct _ssPortOutputs));
8772 ss_VALIDATE_MEMORY(rts,outputPortInfo);
8773 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
8774 _ssSetNumOutputPorts(childS, 1);
8775
8776 /* port 0 */
8777 {
8778 _ssSetOutputPortNumDimensions(childS, 0, 1);
8779 ssSetOutputPortWidth(childS, 0, 1);
8780 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
8781 ssGetLocalBlockIO(rts))->GeneratedSFunction4_d));
8782 }
8783 }
8784
8785 /* path info */
8786 _ssSetModelName(childS, "LagFilter_sf");
8787 _ssSetPath(childS,
8788 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/ lag filter1/Generated S-Function4");
8789 if (ssGetRTModel(rts) == (NULL)) {
8790 _ssSetParentSS(childS, rts);
8791 _ssSetRootSS(childS, ssGetRootSS(rts));
8792 } else {
8793 ssSetRTModel(childS,ssGetRTModel(rts));
8794 _ssSetParentSS(childS, (NULL));
8795 _ssSetRootSS(childS, childS);
8796 }
8797
8798 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
8799
8800 /* work vectors */
8801 {
8802 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
8803 (4 * sizeof(struct _ssDWorkRecord));
8804 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
8805 calloc(4, sizeof(struct _ssDWorkAuxRecord));
8806 ss_VALIDATE_MEMORY(rts,dWorkRecord);
8807 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
8808 ssSetSFcnDWork(childS, dWorkRecord);
8809 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
8810 _ssSetNumDWork(childS, 4);
8811
8812 /* DWORK0 */
8813 ssSetDWorkWidth(childS, 0, 1);
8814 ssSetDWorkDataType(childS, 0,SS_SINGLE);
8815 ssSetDWorkComplexSignal(childS, 0, 0);
8816 ssSetDWorkUsedAsDState(childS, 0, 1);
8817 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 172))[0]);
8818
8819 /* DWORK1 */
8820 ssSetDWorkWidth(childS, 1, 1);
8821 ssSetDWorkDataType(childS, 1,SS_SINGLE);
8822 ssSetDWorkComplexSignal(childS, 1, 0);
8823 ssSetDWorkUsedAsDState(childS, 1, 1);
8824 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 173))[0]);
8825
8826 /* DWORK2 */
8827 ssSetDWorkWidth(childS, 2, 1);
8828 ssSetDWorkDataType(childS, 2,SS_INT8);
8829 ssSetDWorkComplexSignal(childS, 2, 0);
8830 ssSetDWorkUsedAsDState(childS, 2, 1);
8831 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 399))[0]);
8832
8833 /* DWORK3 */
8834 ssSetDWorkWidth(childS, 3, 1);
8835 ssSetDWorkDataType(childS, 3,SS_INT8);
8836 ssSetDWorkComplexSignal(childS, 3, 0);
8837 ssSetDWorkUsedAsDState(childS, 3, 1);
8838 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 400))[0]);
8839 }
8840
8841 (childS)->regDataType.arg1 = ((void *)(childS));
8842 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
8843 FcnSetErrorStatus);
8844 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
8845 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
8846 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
8847 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
8848
8849 /* registration */
8850#if defined(MATLAB_MEX_FILE)
8851
8852 {
8853 int_T i;
8854 mxArray *plhs[1];
8855 mxArray *prhs[4];
8856 double *pr;
8857 volatile int_T *intS = (int_T *)&childS;
8858 int_T addrlen = sizeof(SimStruct *);
8859 int_T m = addrlen/sizeof(int_T) + 1;
8860 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
8861 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
8862 pr = mxGetPr(prhs[1]);
8863 for (i = 0; i < m - 1; i++) {
8864 pr[i] = (double)intS[i];
8865 }
8866
8867 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
8868 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
8869 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
8870
8871 /* Reset port dimensions info functions because the S-function
8872 * and accelerator mex-files explicitly set their dimensions,
8873 * i.e., they are not dynamically sized. For this case, the
8874 * mex-file is responsible for the dimensions info memory
8875 * and Simulink should not free it. This is achieved by
8876 * setting the following two methods to NULL.
8877 */
8878 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
8879 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
8880
8881 /*
8882 * Setup function pointers and call mdlInitializeSizes via
8883 * simulink.c
8884 */
8885 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
8886 mxDestroyArray(plhs[0]);
8887 mxDestroyArray(prhs[0]);
8888 mxDestroyArray(prhs[1]);
8889 mxDestroyArray(prhs[2]);
8890 mxDestroyArray(prhs[3]);
8891 }
8892
8893#else
8894
8895 {
8896 LagFilter_sf(childS);
8897 sfcnInitializeSizes(childS);
8898 }
8899
8900#endif
8901
8902 sfcnInitializeSampleTimes(childS);
8903
8904 /* adjust sample time */
8905 ssSetSampleTime(childS, 0, 0.0);
8906 ssSetOffsetTime(childS, 0, 0.0);
8907 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
8908
8909 /* set compiled values of dynamic vector attributes */
8910 ssSetNumNonsampledZCs(childS, 0);
8911
8912 /* Update connectivity flags for each port */
8913 _ssSetInputPortConnected(childS, 0, 1);
8914 _ssSetInputPortConnected(childS, 1, 1);
8915 _ssSetInputPortConnected(childS, 2, 1);
8916 _ssSetInputPortConnected(childS, 3, 1);
8917 _ssSetInputPortConnected(childS, 4, 1);
8918 _ssSetInputPortConnected(childS, 5, 1);
8919 _ssSetOutputPortConnected(childS, 0, 1);
8920 _ssSetOutputPortBeingMerged(childS, 0, 0);
8921
8922 /* Update the BufferDstPort flags for each input port */
8923 _ssSetInputPortBufferDstPort(childS, 0, -1);
8924 _ssSetInputPortBufferDstPort(childS, 1, -1);
8925 _ssSetInputPortBufferDstPort(childS, 2, -1);
8926 _ssSetInputPortBufferDstPort(childS, 3, -1);
8927 _ssSetInputPortBufferDstPort(childS, 4, -1);
8928 _ssSetInputPortBufferDstPort(childS, 5, -1);
8929 }
8930
8931 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S122>/Generated S-Function (Gain_sf) */
8932 {
8933 SimStruct *childS = ssGetSFunction(rts, 33);
8934
8935 /* timing info */
8936 time_T *sfcnPeriod;
8937 time_T *sfcnOffset;
8938 int_T *sfcnTsMap;
8939 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
8940 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
8941 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
8942 ss_VALIDATE_MEMORY(rts,sfcnOffset);
8943 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
8944 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
8945 (void) memset((void*)sfcnPeriod, 0,
8946 sizeof(time_T)*1);
8947 (void) memset((void*)sfcnOffset, 0,
8948 sizeof(time_T)*1);
8949 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
8950 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
8951 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
8952
8953 /* Set up the mdlInfo pointer */
8954# ifdef USE_RTMODEL
8955
8956 {
8957 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
8958 struct _ssBlkInfo2));
8959 ss_VALIDATE_MEMORY(rts,blkInfo2);
8960 ssSetBlkInfo2Ptr(childS, blkInfo2);
8961 }
8962
8963 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
8964
8965# else
8966
8967 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
8968
8969# endif /* USE_RTMODEL */
8970
8971 /* Allocate memory of model methods 2 */
8972 {
8973 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
8974 malloc(sizeof(struct _ssSFcnModelMethods2));
8975 ss_VALIDATE_MEMORY(rts,methods2);
8976 ssSetModelMethods2(childS, methods2);
8977 }
8978
8979 /* Allocate memory of model methods 3 */
8980 {
8981 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
8982 malloc(sizeof(struct _ssSFcnModelMethods3));
8983 ss_VALIDATE_MEMORY(rts,methods3);
8984 ssSetModelMethods3(childS, methods3);
8985 }
8986
8987 /* Allocate memory for states auxilliary information */
8988 {
8989 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
8990 (sizeof(struct _ssStatesInfo2));
8991 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
8992 malloc(sizeof(ssPeriodicStatesInfo));
8993 ss_VALIDATE_MEMORY(rts,statesInfo2);
8994 ssSetStatesInfo2(childS, statesInfo2);
8995 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
8996 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
8997 }
8998
8999 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
9000 RegNumInputPorts);
9001 ssSetRegNumInputPortsFcnArg(childS,childS);
9002
9003 /* inputs */
9004 {
9005 struct _ssPortInputs *inputPortInfo =
9006 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
9007 ss_VALIDATE_MEMORY(rts,inputPortInfo);
9008 _ssSetNumInputPorts(childS, 2);
9009 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
9010
9011 /* port 0 */
9012 {
9013 real32_T const **sfcnUPtrs = (real32_T const **)
9014 malloc(1 * sizeof(real32_T *));
9015 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9016 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
9017 ssGetLocalBlockIO(rts))->GeneratedSFunction4_d;
9018 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
9019 _ssSetInputPortNumDimensions(childS, 0, 1);
9020 ssSetInputPortWidth(childS, 0, 1);
9021 }
9022
9023 /* port 1 */
9024 {
9025 real32_T const **sfcnUPtrs = (real32_T const **)
9026 malloc(1 * sizeof(real32_T *));
9027 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9028 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
9029 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
9030 _ssSetInputPortNumDimensions(childS, 1, 1);
9031 ssSetInputPortWidth(childS, 1, 1);
9032 }
9033 }
9034
9035 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
9036 RegNumOutputPorts);
9037 ssSetRegNumOutputPortsFcnArg(childS,childS);
9038
9039 /* outputs */
9040 {
9041 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
9042 calloc(1, sizeof(struct _ssPortOutputs));
9043 ss_VALIDATE_MEMORY(rts,outputPortInfo);
9044 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
9045 _ssSetNumOutputPorts(childS, 1);
9046
9047 /* port 0 */
9048 {
9049 _ssSetOutputPortNumDimensions(childS, 0, 1);
9050 ssSetOutputPortWidth(childS, 0, 1);
9051 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
9052 ssGetLocalBlockIO(rts))->Switch6_d));
9053 }
9054 }
9055
9056 /* path info */
9057 _ssSetModelName(childS, "Gain_sf");
9058 _ssSetPath(childS,
9059 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/gain1/Generated S-Function");
9060 if (ssGetRTModel(rts) == (NULL)) {
9061 _ssSetParentSS(childS, rts);
9062 _ssSetRootSS(childS, ssGetRootSS(rts));
9063 } else {
9064 ssSetRTModel(childS,ssGetRTModel(rts));
9065 _ssSetParentSS(childS, (NULL));
9066 _ssSetRootSS(childS, childS);
9067 }
9068
9069 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
9070 (childS)->regDataType.arg1 = ((void *)(childS));
9071 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
9072 FcnSetErrorStatus);
9073 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
9074 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
9075 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
9076 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
9077
9078 /* registration */
9079#if defined(MATLAB_MEX_FILE)
9080
9081 {
9082 int_T i;
9083 mxArray *plhs[1];
9084 mxArray *prhs[4];
9085 double *pr;
9086 volatile int_T *intS = (int_T *)&childS;
9087 int_T addrlen = sizeof(SimStruct *);
9088 int_T m = addrlen/sizeof(int_T) + 1;
9089 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
9090 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
9091 pr = mxGetPr(prhs[1]);
9092 for (i = 0; i < m - 1; i++) {
9093 pr[i] = (double)intS[i];
9094 }
9095
9096 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
9097 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
9098 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
9099
9100 /* Reset port dimensions info functions because the S-function
9101 * and accelerator mex-files explicitly set their dimensions,
9102 * i.e., they are not dynamically sized. For this case, the
9103 * mex-file is responsible for the dimensions info memory
9104 * and Simulink should not free it. This is achieved by
9105 * setting the following two methods to NULL.
9106 */
9107 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
9108 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
9109
9110 /*
9111 * Setup function pointers and call mdlInitializeSizes via
9112 * simulink.c
9113 */
9114 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
9115 mxDestroyArray(plhs[0]);
9116 mxDestroyArray(prhs[0]);
9117 mxDestroyArray(prhs[1]);
9118 mxDestroyArray(prhs[2]);
9119 mxDestroyArray(prhs[3]);
9120 }
9121
9122#else
9123
9124 {
9125 Gain_sf(childS);
9126 sfcnInitializeSizes(childS);
9127 }
9128
9129#endif
9130
9131 sfcnInitializeSampleTimes(childS);
9132
9133 /* adjust sample time */
9134 ssSetSampleTime(childS, 0, 0.0);
9135 ssSetOffsetTime(childS, 0, 0.0);
9136 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
9137
9138 /* set compiled values of dynamic vector attributes */
9139 ssSetNumNonsampledZCs(childS, 0);
9140
9141 /* Update connectivity flags for each port */
9142 _ssSetInputPortConnected(childS, 0, 1);
9143 _ssSetInputPortConnected(childS, 1, 1);
9144 _ssSetOutputPortConnected(childS, 0, 1);
9145 _ssSetOutputPortBeingMerged(childS, 0, 0);
9146
9147 /* Update the BufferDstPort flags for each input port */
9148 _ssSetInputPortBufferDstPort(childS, 0, -1);
9149 _ssSetInputPortBufferDstPort(childS, 1, -1);
9150 }
9151
9152 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S116>/Generated S-Function4 (LagFilter_sf) */
9153 {
9154 SimStruct *childS = ssGetSFunction(rts, 34);
9155
9156 /* timing info */
9157 time_T *sfcnPeriod;
9158 time_T *sfcnOffset;
9159 int_T *sfcnTsMap;
9160 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
9161 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
9162 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
9163 ss_VALIDATE_MEMORY(rts,sfcnOffset);
9164 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
9165 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
9166 (void) memset((void*)sfcnPeriod, 0,
9167 sizeof(time_T)*1);
9168 (void) memset((void*)sfcnOffset, 0,
9169 sizeof(time_T)*1);
9170 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
9171 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
9172 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
9173
9174 /* Set up the mdlInfo pointer */
9175# ifdef USE_RTMODEL
9176
9177 {
9178 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
9179 struct _ssBlkInfo2));
9180 ss_VALIDATE_MEMORY(rts,blkInfo2);
9181 ssSetBlkInfo2Ptr(childS, blkInfo2);
9182 }
9183
9184 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
9185
9186# else
9187
9188 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
9189
9190# endif /* USE_RTMODEL */
9191
9192 /* Allocate memory of model methods 2 */
9193 {
9194 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
9195 malloc(sizeof(struct _ssSFcnModelMethods2));
9196 ss_VALIDATE_MEMORY(rts,methods2);
9197 ssSetModelMethods2(childS, methods2);
9198 }
9199
9200 /* Allocate memory of model methods 3 */
9201 {
9202 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
9203 malloc(sizeof(struct _ssSFcnModelMethods3));
9204 ss_VALIDATE_MEMORY(rts,methods3);
9205 ssSetModelMethods3(childS, methods3);
9206 }
9207
9208 /* Allocate memory for states auxilliary information */
9209 {
9210 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
9211 (sizeof(struct _ssStatesInfo2));
9212 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
9213 malloc(sizeof(ssPeriodicStatesInfo));
9214 ss_VALIDATE_MEMORY(rts,statesInfo2);
9215 ssSetStatesInfo2(childS, statesInfo2);
9216 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
9217 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
9218 }
9219
9220 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
9221 RegNumInputPorts);
9222 ssSetRegNumInputPortsFcnArg(childS,childS);
9223
9224 /* inputs */
9225 {
9226 struct _ssPortInputs *inputPortInfo =
9227 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
9228 ss_VALIDATE_MEMORY(rts,inputPortInfo);
9229 _ssSetNumInputPorts(childS, 6);
9230 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
9231
9232 /* port 0 */
9233 {
9234 real32_T const **sfcnUPtrs = (real32_T const **)
9235 malloc(1 * sizeof(real32_T *));
9236 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9237 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
9238 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
9239 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
9240 _ssSetInputPortNumDimensions(childS, 0, 1);
9241 ssSetInputPortWidth(childS, 0, 1);
9242 }
9243
9244 /* port 1 */
9245 {
9246 int8_T const **sfcnUPtrs = (int8_T const **)
9247 malloc(1 * sizeof(int8_T *));
9248 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9249 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
9250 ssGetLocalBlockIO(rts))->DataTypeConversion1_p;
9251 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
9252 _ssSetInputPortNumDimensions(childS, 1, 1);
9253 ssSetInputPortWidth(childS, 1, 1);
9254 }
9255
9256 /* port 2 */
9257 {
9258 real32_T const **sfcnUPtrs = (real32_T const **)
9259 malloc(1 * sizeof(real32_T *));
9260 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9261 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
9262 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
9263 _ssSetInputPortNumDimensions(childS, 2, 1);
9264 ssSetInputPortWidth(childS, 2, 1);
9265 }
9266
9267 /* port 3 */
9268 {
9269 real32_T const **sfcnUPtrs = (real32_T const **)
9270 malloc(1 * sizeof(real32_T *));
9271 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9272 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
9273 ssGetLocalBlockIO(rts))->Switch_aj;
9274 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
9275 _ssSetInputPortNumDimensions(childS, 3, 1);
9276 ssSetInputPortWidth(childS, 3, 1);
9277 }
9278
9279 /* port 4 */
9280 {
9281 real32_T const **sfcnUPtrs = (real32_T const **)
9282 malloc(1 * sizeof(real32_T *));
9283 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9284 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
9285 ssGetLocalBlockIO(rts))->Switch_aj;
9286 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
9287 _ssSetInputPortNumDimensions(childS, 4, 1);
9288 ssSetInputPortWidth(childS, 4, 1);
9289 }
9290
9291 /* port 5 */
9292 {
9293 real32_T const **sfcnUPtrs = (real32_T const **)
9294 malloc(1 * sizeof(real32_T *));
9295 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9296 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
9297 ssGetLocalBlockIO(rts))->Sum3_l;
9298 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
9299 _ssSetInputPortNumDimensions(childS, 5, 1);
9300 ssSetInputPortWidth(childS, 5, 1);
9301 }
9302 }
9303
9304 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
9305 RegNumOutputPorts);
9306 ssSetRegNumOutputPortsFcnArg(childS,childS);
9307
9308 /* outputs */
9309 {
9310 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
9311 calloc(1, sizeof(struct _ssPortOutputs));
9312 ss_VALIDATE_MEMORY(rts,outputPortInfo);
9313 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
9314 _ssSetNumOutputPorts(childS, 1);
9315
9316 /* port 0 */
9317 {
9318 _ssSetOutputPortNumDimensions(childS, 0, 1);
9319 ssSetOutputPortWidth(childS, 0, 1);
9320 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
9321 ssGetLocalBlockIO(rts))->GeneratedSFunction4_f));
9322 }
9323 }
9324
9325 /* path info */
9326 _ssSetModelName(childS, "LagFilter_sf");
9327 _ssSetPath(childS,
9328 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/ThetaLControl/ lag filter/Generated S-Function4");
9329 if (ssGetRTModel(rts) == (NULL)) {
9330 _ssSetParentSS(childS, rts);
9331 _ssSetRootSS(childS, ssGetRootSS(rts));
9332 } else {
9333 ssSetRTModel(childS,ssGetRTModel(rts));
9334 _ssSetParentSS(childS, (NULL));
9335 _ssSetRootSS(childS, childS);
9336 }
9337
9338 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
9339
9340 /* work vectors */
9341 {
9342 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
9343 (4 * sizeof(struct _ssDWorkRecord));
9344 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
9345 calloc(4, sizeof(struct _ssDWorkAuxRecord));
9346 ss_VALIDATE_MEMORY(rts,dWorkRecord);
9347 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
9348 ssSetSFcnDWork(childS, dWorkRecord);
9349 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
9350 _ssSetNumDWork(childS, 4);
9351
9352 /* DWORK0 */
9353 ssSetDWorkWidth(childS, 0, 1);
9354 ssSetDWorkDataType(childS, 0,SS_SINGLE);
9355 ssSetDWorkComplexSignal(childS, 0, 0);
9356 ssSetDWorkUsedAsDState(childS, 0, 1);
9357 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 174))[0]);
9358
9359 /* DWORK1 */
9360 ssSetDWorkWidth(childS, 1, 1);
9361 ssSetDWorkDataType(childS, 1,SS_SINGLE);
9362 ssSetDWorkComplexSignal(childS, 1, 0);
9363 ssSetDWorkUsedAsDState(childS, 1, 1);
9364 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 175))[0]);
9365
9366 /* DWORK2 */
9367 ssSetDWorkWidth(childS, 2, 1);
9368 ssSetDWorkDataType(childS, 2,SS_INT8);
9369 ssSetDWorkComplexSignal(childS, 2, 0);
9370 ssSetDWorkUsedAsDState(childS, 2, 1);
9371 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 401))[0]);
9372
9373 /* DWORK3 */
9374 ssSetDWorkWidth(childS, 3, 1);
9375 ssSetDWorkDataType(childS, 3,SS_INT8);
9376 ssSetDWorkComplexSignal(childS, 3, 0);
9377 ssSetDWorkUsedAsDState(childS, 3, 1);
9378 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 402))[0]);
9379 }
9380
9381 (childS)->regDataType.arg1 = ((void *)(childS));
9382 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
9383 FcnSetErrorStatus);
9384 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
9385 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
9386 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
9387 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
9388
9389 /* registration */
9390#if defined(MATLAB_MEX_FILE)
9391
9392 {
9393 int_T i;
9394 mxArray *plhs[1];
9395 mxArray *prhs[4];
9396 double *pr;
9397 volatile int_T *intS = (int_T *)&childS;
9398 int_T addrlen = sizeof(SimStruct *);
9399 int_T m = addrlen/sizeof(int_T) + 1;
9400 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
9401 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
9402 pr = mxGetPr(prhs[1]);
9403 for (i = 0; i < m - 1; i++) {
9404 pr[i] = (double)intS[i];
9405 }
9406
9407 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
9408 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
9409 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
9410
9411 /* Reset port dimensions info functions because the S-function
9412 * and accelerator mex-files explicitly set their dimensions,
9413 * i.e., they are not dynamically sized. For this case, the
9414 * mex-file is responsible for the dimensions info memory
9415 * and Simulink should not free it. This is achieved by
9416 * setting the following two methods to NULL.
9417 */
9418 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
9419 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
9420
9421 /*
9422 * Setup function pointers and call mdlInitializeSizes via
9423 * simulink.c
9424 */
9425 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
9426 mxDestroyArray(plhs[0]);
9427 mxDestroyArray(prhs[0]);
9428 mxDestroyArray(prhs[1]);
9429 mxDestroyArray(prhs[2]);
9430 mxDestroyArray(prhs[3]);
9431 }
9432
9433#else
9434
9435 {
9436 LagFilter_sf(childS);
9437 sfcnInitializeSizes(childS);
9438 }
9439
9440#endif
9441
9442 sfcnInitializeSampleTimes(childS);
9443
9444 /* adjust sample time */
9445 ssSetSampleTime(childS, 0, 0.0);
9446 ssSetOffsetTime(childS, 0, 0.0);
9447 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
9448
9449 /* set compiled values of dynamic vector attributes */
9450 ssSetNumNonsampledZCs(childS, 0);
9451
9452 /* Update connectivity flags for each port */
9453 _ssSetInputPortConnected(childS, 0, 1);
9454 _ssSetInputPortConnected(childS, 1, 1);
9455 _ssSetInputPortConnected(childS, 2, 1);
9456 _ssSetInputPortConnected(childS, 3, 1);
9457 _ssSetInputPortConnected(childS, 4, 1);
9458 _ssSetInputPortConnected(childS, 5, 1);
9459 _ssSetOutputPortConnected(childS, 0, 1);
9460 _ssSetOutputPortBeingMerged(childS, 0, 0);
9461
9462 /* Update the BufferDstPort flags for each input port */
9463 _ssSetInputPortBufferDstPort(childS, 0, -1);
9464 _ssSetInputPortBufferDstPort(childS, 1, -1);
9465 _ssSetInputPortBufferDstPort(childS, 2, -1);
9466 _ssSetInputPortBufferDstPort(childS, 3, -1);
9467 _ssSetInputPortBufferDstPort(childS, 4, -1);
9468 _ssSetInputPortBufferDstPort(childS, 5, -1);
9469 }
9470
9471 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S102>/Generated S-Function1 (SaturationLimiter_sf) */
9472 {
9473 SimStruct *childS = ssGetSFunction(rts, 35);
9474
9475 /* timing info */
9476 time_T *sfcnPeriod;
9477 time_T *sfcnOffset;
9478 int_T *sfcnTsMap;
9479 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
9480 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
9481 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
9482 ss_VALIDATE_MEMORY(rts,sfcnOffset);
9483 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
9484 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
9485 (void) memset((void*)sfcnPeriod, 0,
9486 sizeof(time_T)*1);
9487 (void) memset((void*)sfcnOffset, 0,
9488 sizeof(time_T)*1);
9489 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
9490 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
9491 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
9492
9493 /* Set up the mdlInfo pointer */
9494# ifdef USE_RTMODEL
9495
9496 {
9497 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
9498 struct _ssBlkInfo2));
9499 ss_VALIDATE_MEMORY(rts,blkInfo2);
9500 ssSetBlkInfo2Ptr(childS, blkInfo2);
9501 }
9502
9503 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
9504
9505# else
9506
9507 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
9508
9509# endif /* USE_RTMODEL */
9510
9511 /* Allocate memory of model methods 2 */
9512 {
9513 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
9514 malloc(sizeof(struct _ssSFcnModelMethods2));
9515 ss_VALIDATE_MEMORY(rts,methods2);
9516 ssSetModelMethods2(childS, methods2);
9517 }
9518
9519 /* Allocate memory of model methods 3 */
9520 {
9521 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
9522 malloc(sizeof(struct _ssSFcnModelMethods3));
9523 ss_VALIDATE_MEMORY(rts,methods3);
9524 ssSetModelMethods3(childS, methods3);
9525 }
9526
9527 /* Allocate memory for states auxilliary information */
9528 {
9529 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
9530 (sizeof(struct _ssStatesInfo2));
9531 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
9532 malloc(sizeof(ssPeriodicStatesInfo));
9533 ss_VALIDATE_MEMORY(rts,statesInfo2);
9534 ssSetStatesInfo2(childS, statesInfo2);
9535 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
9536 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
9537 }
9538
9539 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
9540 RegNumInputPorts);
9541 ssSetRegNumInputPortsFcnArg(childS,childS);
9542
9543 /* inputs */
9544 {
9545 struct _ssPortInputs *inputPortInfo =
9546 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
9547 ss_VALIDATE_MEMORY(rts,inputPortInfo);
9548 _ssSetNumInputPorts(childS, 3);
9549 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
9550
9551 /* port 0 */
9552 {
9553 real32_T const **sfcnUPtrs = (real32_T const **)
9554 malloc(1 * sizeof(real32_T *));
9555 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9556 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
9557 ssGetLocalBlockIO(rts))->Sum1_l;
9558 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
9559 _ssSetInputPortNumDimensions(childS, 0, 1);
9560 ssSetInputPortWidth(childS, 0, 1);
9561 }
9562
9563 /* port 1 */
9564 {
9565 real32_T const **sfcnUPtrs = (real32_T const **)
9566 malloc(1 * sizeof(real32_T *));
9567 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9568 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;
9569 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
9570 _ssSetInputPortNumDimensions(childS, 1, 1);
9571 ssSetInputPortWidth(childS, 1, 1);
9572 }
9573
9574 /* port 2 */
9575 {
9576 real32_T const **sfcnUPtrs = (real32_T const **)
9577 malloc(1 * sizeof(real32_T *));
9578 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9579 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;
9580 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
9581 _ssSetInputPortNumDimensions(childS, 2, 1);
9582 ssSetInputPortWidth(childS, 2, 1);
9583 }
9584 }
9585
9586 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
9587 RegNumOutputPorts);
9588 ssSetRegNumOutputPortsFcnArg(childS,childS);
9589
9590 /* outputs */
9591 {
9592 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
9593 calloc(1, sizeof(struct _ssPortOutputs));
9594 ss_VALIDATE_MEMORY(rts,outputPortInfo);
9595 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
9596 _ssSetNumOutputPorts(childS, 1);
9597
9598 /* port 0 */
9599 {
9600 _ssSetOutputPortNumDimensions(childS, 0, 1);
9601 ssSetOutputPortWidth(childS, 0, 1);
9602 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
9603 ssGetLocalBlockIO(rts))->GeneratedSFunction1_n));
9604 }
9605 }
9606
9607 /* path info */
9608 _ssSetModelName(childS, "SaturationLimiter_sf");
9609 _ssSetPath(childS,
9610 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/Saturation Limiter1/Generated S-Function1");
9611 if (ssGetRTModel(rts) == (NULL)) {
9612 _ssSetParentSS(childS, rts);
9613 _ssSetRootSS(childS, ssGetRootSS(rts));
9614 } else {
9615 ssSetRTModel(childS,ssGetRTModel(rts));
9616 _ssSetParentSS(childS, (NULL));
9617 _ssSetRootSS(childS, childS);
9618 }
9619
9620 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
9621 (childS)->regDataType.arg1 = ((void *)(childS));
9622 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
9623 FcnSetErrorStatus);
9624 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
9625 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
9626 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
9627 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
9628
9629 /* registration */
9630#if defined(MATLAB_MEX_FILE)
9631
9632 {
9633 int_T i;
9634 mxArray *plhs[1];
9635 mxArray *prhs[4];
9636 double *pr;
9637 volatile int_T *intS = (int_T *)&childS;
9638 int_T addrlen = sizeof(SimStruct *);
9639 int_T m = addrlen/sizeof(int_T) + 1;
9640 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
9641 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
9642 pr = mxGetPr(prhs[1]);
9643 for (i = 0; i < m - 1; i++) {
9644 pr[i] = (double)intS[i];
9645 }
9646
9647 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
9648 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
9649 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
9650
9651 /* Reset port dimensions info functions because the S-function
9652 * and accelerator mex-files explicitly set their dimensions,
9653 * i.e., they are not dynamically sized. For this case, the
9654 * mex-file is responsible for the dimensions info memory
9655 * and Simulink should not free it. This is achieved by
9656 * setting the following two methods to NULL.
9657 */
9658 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
9659 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
9660
9661 /*
9662 * Setup function pointers and call mdlInitializeSizes via
9663 * simulink.c
9664 */
9665 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
9666 mxDestroyArray(plhs[0]);
9667 mxDestroyArray(prhs[0]);
9668 mxDestroyArray(prhs[1]);
9669 mxDestroyArray(prhs[2]);
9670 mxDestroyArray(prhs[3]);
9671 }
9672
9673#else
9674
9675 {
9676 SaturationLimiter_sf(childS);
9677 sfcnInitializeSizes(childS);
9678 }
9679
9680#endif
9681
9682 sfcnInitializeSampleTimes(childS);
9683
9684 /* adjust sample time */
9685 ssSetSampleTime(childS, 0, 0.0);
9686 ssSetOffsetTime(childS, 0, 0.0);
9687 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
9688
9689 /* set compiled values of dynamic vector attributes */
9690 ssSetNumNonsampledZCs(childS, 0);
9691
9692 /* Update connectivity flags for each port */
9693 _ssSetInputPortConnected(childS, 0, 1);
9694 _ssSetInputPortConnected(childS, 1, 1);
9695 _ssSetInputPortConnected(childS, 2, 1);
9696 _ssSetOutputPortConnected(childS, 0, 1);
9697 _ssSetOutputPortBeingMerged(childS, 0, 0);
9698
9699 /* Update the BufferDstPort flags for each input port */
9700 _ssSetInputPortBufferDstPort(childS, 0, -1);
9701 _ssSetInputPortBufferDstPort(childS, 1, -1);
9702 _ssSetInputPortBufferDstPort(childS, 2, -1);
9703 }
9704
9705 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S104>/Generated S-Function (Gain_sf) */
9706 {
9707 SimStruct *childS = ssGetSFunction(rts, 36);
9708
9709 /* timing info */
9710 time_T *sfcnPeriod;
9711 time_T *sfcnOffset;
9712 int_T *sfcnTsMap;
9713 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
9714 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
9715 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
9716 ss_VALIDATE_MEMORY(rts,sfcnOffset);
9717 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
9718 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
9719 (void) memset((void*)sfcnPeriod, 0,
9720 sizeof(time_T)*1);
9721 (void) memset((void*)sfcnOffset, 0,
9722 sizeof(time_T)*1);
9723 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
9724 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
9725 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
9726
9727 /* Set up the mdlInfo pointer */
9728# ifdef USE_RTMODEL
9729
9730 {
9731 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
9732 struct _ssBlkInfo2));
9733 ss_VALIDATE_MEMORY(rts,blkInfo2);
9734 ssSetBlkInfo2Ptr(childS, blkInfo2);
9735 }
9736
9737 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
9738
9739# else
9740
9741 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
9742
9743# endif /* USE_RTMODEL */
9744
9745 /* Allocate memory of model methods 2 */
9746 {
9747 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
9748 malloc(sizeof(struct _ssSFcnModelMethods2));
9749 ss_VALIDATE_MEMORY(rts,methods2);
9750 ssSetModelMethods2(childS, methods2);
9751 }
9752
9753 /* Allocate memory of model methods 3 */
9754 {
9755 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
9756 malloc(sizeof(struct _ssSFcnModelMethods3));
9757 ss_VALIDATE_MEMORY(rts,methods3);
9758 ssSetModelMethods3(childS, methods3);
9759 }
9760
9761 /* Allocate memory for states auxilliary information */
9762 {
9763 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
9764 (sizeof(struct _ssStatesInfo2));
9765 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
9766 malloc(sizeof(ssPeriodicStatesInfo));
9767 ss_VALIDATE_MEMORY(rts,statesInfo2);
9768 ssSetStatesInfo2(childS, statesInfo2);
9769 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
9770 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
9771 }
9772
9773 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
9774 RegNumInputPorts);
9775 ssSetRegNumInputPortsFcnArg(childS,childS);
9776
9777 /* inputs */
9778 {
9779 struct _ssPortInputs *inputPortInfo =
9780 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
9781 ss_VALIDATE_MEMORY(rts,inputPortInfo);
9782 _ssSetNumInputPorts(childS, 2);
9783 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
9784
9785 /* port 0 */
9786 {
9787 real32_T const **sfcnUPtrs = (real32_T const **)
9788 malloc(1 * sizeof(real32_T *));
9789 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9790 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
9791 ssGetLocalBlockIO(rts))->GeneratedSFunction1_n;
9792 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
9793 _ssSetInputPortNumDimensions(childS, 0, 1);
9794 ssSetInputPortWidth(childS, 0, 1);
9795 }
9796
9797 /* port 1 */
9798 {
9799 real32_T const **sfcnUPtrs = (real32_T const **)
9800 malloc(1 * sizeof(real32_T *));
9801 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
9802 sfcnUPtrs[0] = (real32_T const *)
9803 &AFCS_MODEL1_ConstP.Constant13_Value_n;
9804 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
9805 _ssSetInputPortNumDimensions(childS, 1, 1);
9806 ssSetInputPortWidth(childS, 1, 1);
9807 }
9808 }
9809
9810 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
9811 RegNumOutputPorts);
9812 ssSetRegNumOutputPortsFcnArg(childS,childS);
9813
9814 /* outputs */
9815 {
9816 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
9817 calloc(1, sizeof(struct _ssPortOutputs));
9818 ss_VALIDATE_MEMORY(rts,outputPortInfo);
9819 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
9820 _ssSetNumOutputPorts(childS, 1);
9821
9822 /* port 0 */
9823 {
9824 _ssSetOutputPortNumDimensions(childS, 0, 1);
9825 ssSetOutputPortWidth(childS, 0, 1);
9826 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
9827 ssGetLocalBlockIO(rts))->GeneratedSFunction_b1));
9828 }
9829 }
9830
9831 /* path info */
9832 _ssSetModelName(childS, "Gain_sf");
9833 _ssSetPath(childS,
9834 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/gain/Generated S-Function");
9835 if (ssGetRTModel(rts) == (NULL)) {
9836 _ssSetParentSS(childS, rts);
9837 _ssSetRootSS(childS, ssGetRootSS(rts));
9838 } else {
9839 ssSetRTModel(childS,ssGetRTModel(rts));
9840 _ssSetParentSS(childS, (NULL));
9841 _ssSetRootSS(childS, childS);
9842 }
9843
9844 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
9845 (childS)->regDataType.arg1 = ((void *)(childS));
9846 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
9847 FcnSetErrorStatus);
9848 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
9849 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
9850 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
9851 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
9852
9853 /* registration */
9854#if defined(MATLAB_MEX_FILE)
9855
9856 {
9857 int_T i;
9858 mxArray *plhs[1];
9859 mxArray *prhs[4];
9860 double *pr;
9861 volatile int_T *intS = (int_T *)&childS;
9862 int_T addrlen = sizeof(SimStruct *);
9863 int_T m = addrlen/sizeof(int_T) + 1;
9864 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
9865 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
9866 pr = mxGetPr(prhs[1]);
9867 for (i = 0; i < m - 1; i++) {
9868 pr[i] = (double)intS[i];
9869 }
9870
9871 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
9872 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
9873 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
9874
9875 /* Reset port dimensions info functions because the S-function
9876 * and accelerator mex-files explicitly set their dimensions,
9877 * i.e., they are not dynamically sized. For this case, the
9878 * mex-file is responsible for the dimensions info memory
9879 * and Simulink should not free it. This is achieved by
9880 * setting the following two methods to NULL.
9881 */
9882 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
9883 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
9884
9885 /*
9886 * Setup function pointers and call mdlInitializeSizes via
9887 * simulink.c
9888 */
9889 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
9890 mxDestroyArray(plhs[0]);
9891 mxDestroyArray(prhs[0]);
9892 mxDestroyArray(prhs[1]);
9893 mxDestroyArray(prhs[2]);
9894 mxDestroyArray(prhs[3]);
9895 }
9896
9897#else
9898
9899 {
9900 Gain_sf(childS);
9901 sfcnInitializeSizes(childS);
9902 }
9903
9904#endif
9905
9906 sfcnInitializeSampleTimes(childS);
9907
9908 /* adjust sample time */
9909 ssSetSampleTime(childS, 0, 0.0);
9910 ssSetOffsetTime(childS, 0, 0.0);
9911 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
9912
9913 /* set compiled values of dynamic vector attributes */
9914 ssSetNumNonsampledZCs(childS, 0);
9915
9916 /* Update connectivity flags for each port */
9917 _ssSetInputPortConnected(childS, 0, 1);
9918 _ssSetInputPortConnected(childS, 1, 1);
9919 _ssSetOutputPortConnected(childS, 0, 1);
9920 _ssSetOutputPortBeingMerged(childS, 0, 0);
9921
9922 /* Update the BufferDstPort flags for each input port */
9923 _ssSetInputPortBufferDstPort(childS, 0, -1);
9924 _ssSetInputPortBufferDstPort(childS, 1, -1);
9925 }
9926
9927 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S105>/Generated S-Function (Gain_sf) */
9928 {
9929 SimStruct *childS = ssGetSFunction(rts, 37);
9930
9931 /* timing info */
9932 time_T *sfcnPeriod;
9933 time_T *sfcnOffset;
9934 int_T *sfcnTsMap;
9935 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
9936 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
9937 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
9938 ss_VALIDATE_MEMORY(rts,sfcnOffset);
9939 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
9940 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
9941 (void) memset((void*)sfcnPeriod, 0,
9942 sizeof(time_T)*1);
9943 (void) memset((void*)sfcnOffset, 0,
9944 sizeof(time_T)*1);
9945 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
9946 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
9947 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
9948
9949 /* Set up the mdlInfo pointer */
9950# ifdef USE_RTMODEL
9951
9952 {
9953 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
9954 struct _ssBlkInfo2));
9955 ss_VALIDATE_MEMORY(rts,blkInfo2);
9956 ssSetBlkInfo2Ptr(childS, blkInfo2);
9957 }
9958
9959 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
9960
9961# else
9962
9963 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
9964
9965# endif /* USE_RTMODEL */
9966
9967 /* Allocate memory of model methods 2 */
9968 {
9969 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
9970 malloc(sizeof(struct _ssSFcnModelMethods2));
9971 ss_VALIDATE_MEMORY(rts,methods2);
9972 ssSetModelMethods2(childS, methods2);
9973 }
9974
9975 /* Allocate memory of model methods 3 */
9976 {
9977 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
9978 malloc(sizeof(struct _ssSFcnModelMethods3));
9979 ss_VALIDATE_MEMORY(rts,methods3);
9980 ssSetModelMethods3(childS, methods3);
9981 }
9982
9983 /* Allocate memory for states auxilliary information */
9984 {
9985 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
9986 (sizeof(struct _ssStatesInfo2));
9987 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
9988 malloc(sizeof(ssPeriodicStatesInfo));
9989 ss_VALIDATE_MEMORY(rts,statesInfo2);
9990 ssSetStatesInfo2(childS, statesInfo2);
9991 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
9992 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
9993 }
9994
9995 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
9996 RegNumInputPorts);
9997 ssSetRegNumInputPortsFcnArg(childS,childS);
9998
9999 /* inputs */
10000 {
10001 struct _ssPortInputs *inputPortInfo =
10002 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
10003 ss_VALIDATE_MEMORY(rts,inputPortInfo);
10004 _ssSetNumInputPorts(childS, 2);
10005 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
10006
10007 /* port 0 */
10008 {
10009 real32_T const **sfcnUPtrs = (real32_T const **)
10010 malloc(1 * sizeof(real32_T *));
10011 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10012 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10013 ssGetLocalBlockIO(rts))->GeneratedSFunction_b1;
10014 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
10015 _ssSetInputPortNumDimensions(childS, 0, 1);
10016 ssSetInputPortWidth(childS, 0, 1);
10017 }
10018
10019 /* port 1 */
10020 {
10021 real32_T const **sfcnUPtrs = (real32_T const **)
10022 malloc(1 * sizeof(real32_T *));
10023 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10024 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
10025 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
10026 _ssSetInputPortNumDimensions(childS, 1, 1);
10027 ssSetInputPortWidth(childS, 1, 1);
10028 }
10029 }
10030
10031 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
10032 RegNumOutputPorts);
10033 ssSetRegNumOutputPortsFcnArg(childS,childS);
10034
10035 /* outputs */
10036 {
10037 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
10038 calloc(1, sizeof(struct _ssPortOutputs));
10039 ss_VALIDATE_MEMORY(rts,outputPortInfo);
10040 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
10041 _ssSetNumOutputPorts(childS, 1);
10042
10043 /* port 0 */
10044 {
10045 _ssSetOutputPortNumDimensions(childS, 0, 1);
10046 ssSetOutputPortWidth(childS, 0, 1);
10047 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
10048 ssGetLocalBlockIO(rts))->GeneratedSFunction_h));
10049 }
10050 }
10051
10052 /* path info */
10053 _ssSetModelName(childS, "Gain_sf");
10054 _ssSetPath(childS,
10055 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/gain4/Generated S-Function");
10056 if (ssGetRTModel(rts) == (NULL)) {
10057 _ssSetParentSS(childS, rts);
10058 _ssSetRootSS(childS, ssGetRootSS(rts));
10059 } else {
10060 ssSetRTModel(childS,ssGetRTModel(rts));
10061 _ssSetParentSS(childS, (NULL));
10062 _ssSetRootSS(childS, childS);
10063 }
10064
10065 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
10066 (childS)->regDataType.arg1 = ((void *)(childS));
10067 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
10068 FcnSetErrorStatus);
10069 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
10070 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
10071 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
10072 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
10073
10074 /* registration */
10075#if defined(MATLAB_MEX_FILE)
10076
10077 {
10078 int_T i;
10079 mxArray *plhs[1];
10080 mxArray *prhs[4];
10081 double *pr;
10082 volatile int_T *intS = (int_T *)&childS;
10083 int_T addrlen = sizeof(SimStruct *);
10084 int_T m = addrlen/sizeof(int_T) + 1;
10085 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
10086 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
10087 pr = mxGetPr(prhs[1]);
10088 for (i = 0; i < m - 1; i++) {
10089 pr[i] = (double)intS[i];
10090 }
10091
10092 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
10093 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
10094 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
10095
10096 /* Reset port dimensions info functions because the S-function
10097 * and accelerator mex-files explicitly set their dimensions,
10098 * i.e., they are not dynamically sized. For this case, the
10099 * mex-file is responsible for the dimensions info memory
10100 * and Simulink should not free it. This is achieved by
10101 * setting the following two methods to NULL.
10102 */
10103 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
10104 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
10105
10106 /*
10107 * Setup function pointers and call mdlInitializeSizes via
10108 * simulink.c
10109 */
10110 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
10111 mxDestroyArray(plhs[0]);
10112 mxDestroyArray(prhs[0]);
10113 mxDestroyArray(prhs[1]);
10114 mxDestroyArray(prhs[2]);
10115 mxDestroyArray(prhs[3]);
10116 }
10117
10118#else
10119
10120 {
10121 Gain_sf(childS);
10122 sfcnInitializeSizes(childS);
10123 }
10124
10125#endif
10126
10127 sfcnInitializeSampleTimes(childS);
10128
10129 /* adjust sample time */
10130 ssSetSampleTime(childS, 0, 0.0);
10131 ssSetOffsetTime(childS, 0, 0.0);
10132 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
10133
10134 /* set compiled values of dynamic vector attributes */
10135 ssSetNumNonsampledZCs(childS, 0);
10136
10137 /* Update connectivity flags for each port */
10138 _ssSetInputPortConnected(childS, 0, 1);
10139 _ssSetInputPortConnected(childS, 1, 1);
10140 _ssSetOutputPortConnected(childS, 0, 1);
10141 _ssSetOutputPortBeingMerged(childS, 0, 0);
10142
10143 /* Update the BufferDstPort flags for each input port */
10144 _ssSetInputPortBufferDstPort(childS, 0, -1);
10145 _ssSetInputPortBufferDstPort(childS, 1, -1);
10146 }
10147
10148 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S100>/Generated S-Function3 (IntegratorLimited_sf) */
10149 {
10150 SimStruct *childS = ssGetSFunction(rts, 38);
10151
10152 /* timing info */
10153 time_T *sfcnPeriod;
10154 time_T *sfcnOffset;
10155 int_T *sfcnTsMap;
10156 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
10157 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
10158 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
10159 ss_VALIDATE_MEMORY(rts,sfcnOffset);
10160 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
10161 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
10162 (void) memset((void*)sfcnPeriod, 0,
10163 sizeof(time_T)*1);
10164 (void) memset((void*)sfcnOffset, 0,
10165 sizeof(time_T)*1);
10166 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
10167 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
10168 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
10169
10170 /* Set up the mdlInfo pointer */
10171# ifdef USE_RTMODEL
10172
10173 {
10174 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
10175 struct _ssBlkInfo2));
10176 ss_VALIDATE_MEMORY(rts,blkInfo2);
10177 ssSetBlkInfo2Ptr(childS, blkInfo2);
10178 }
10179
10180 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
10181
10182# else
10183
10184 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
10185
10186# endif /* USE_RTMODEL */
10187
10188 /* Allocate memory of model methods 2 */
10189 {
10190 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
10191 malloc(sizeof(struct _ssSFcnModelMethods2));
10192 ss_VALIDATE_MEMORY(rts,methods2);
10193 ssSetModelMethods2(childS, methods2);
10194 }
10195
10196 /* Allocate memory of model methods 3 */
10197 {
10198 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
10199 malloc(sizeof(struct _ssSFcnModelMethods3));
10200 ss_VALIDATE_MEMORY(rts,methods3);
10201 ssSetModelMethods3(childS, methods3);
10202 }
10203
10204 /* Allocate memory for states auxilliary information */
10205 {
10206 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
10207 (sizeof(struct _ssStatesInfo2));
10208 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
10209 malloc(sizeof(ssPeriodicStatesInfo));
10210 ss_VALIDATE_MEMORY(rts,statesInfo2);
10211 ssSetStatesInfo2(childS, statesInfo2);
10212 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
10213 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
10214 }
10215
10216 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
10217 RegNumInputPorts);
10218 ssSetRegNumInputPortsFcnArg(childS,childS);
10219
10220 /* inputs */
10221 {
10222 struct _ssPortInputs *inputPortInfo =
10223 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
10224 ss_VALIDATE_MEMORY(rts,inputPortInfo);
10225 _ssSetNumInputPorts(childS, 7);
10226 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
10227
10228 /* port 0 */
10229 {
10230 real32_T const **sfcnUPtrs = (real32_T const **)
10231 malloc(1 * sizeof(real32_T *));
10232 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10233 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10234 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
10235 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
10236 _ssSetInputPortNumDimensions(childS, 0, 1);
10237 ssSetInputPortWidth(childS, 0, 1);
10238 }
10239
10240 /* port 1 */
10241 {
10242 int8_T const **sfcnUPtrs = (int8_T const **)
10243 malloc(1 * sizeof(int8_T *));
10244 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10245 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
10246 ssGetLocalBlockIO(rts))->DataTypeConversion2_c;
10247 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
10248 _ssSetInputPortNumDimensions(childS, 1, 1);
10249 ssSetInputPortWidth(childS, 1, 1);
10250 }
10251
10252 /* port 2 */
10253 {
10254 real32_T const **sfcnUPtrs = (real32_T const **)
10255 malloc(1 * sizeof(real32_T *));
10256 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10257 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
10258 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
10259 _ssSetInputPortNumDimensions(childS, 2, 1);
10260 ssSetInputPortWidth(childS, 2, 1);
10261 }
10262
10263 /* port 3 */
10264 {
10265 real32_T const **sfcnUPtrs = (real32_T const **)
10266 malloc(1 * sizeof(real32_T *));
10267 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10268 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
10269 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
10270 _ssSetInputPortNumDimensions(childS, 3, 1);
10271 ssSetInputPortWidth(childS, 3, 1);
10272 }
10273
10274 /* port 4 */
10275 {
10276 real32_T const **sfcnUPtrs = (real32_T const **)
10277 malloc(1 * sizeof(real32_T *));
10278 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10279 sfcnUPtrs[0] = (real32_T const *)
10280 &AFCS_MODEL1_ConstP.Constant19_Value;
10281 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
10282 _ssSetInputPortNumDimensions(childS, 4, 1);
10283 ssSetInputPortWidth(childS, 4, 1);
10284 }
10285
10286 /* port 5 */
10287 {
10288 real32_T const **sfcnUPtrs = (real32_T const **)
10289 malloc(1 * sizeof(real32_T *));
10290 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10291 sfcnUPtrs[0] = (real32_T const *)
10292 &AFCS_MODEL1_ConstP.Constant76_Value;
10293 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
10294 _ssSetInputPortNumDimensions(childS, 5, 1);
10295 ssSetInputPortWidth(childS, 5, 1);
10296 }
10297
10298 /* port 6 */
10299 {
10300 real32_T const **sfcnUPtrs = (real32_T const **)
10301 malloc(1 * sizeof(real32_T *));
10302 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10303 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10304 ssGetLocalBlockIO(rts))->GeneratedSFunction_h;
10305 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
10306 _ssSetInputPortNumDimensions(childS, 6, 1);
10307 ssSetInputPortWidth(childS, 6, 1);
10308 }
10309 }
10310
10311 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
10312 RegNumOutputPorts);
10313 ssSetRegNumOutputPortsFcnArg(childS,childS);
10314
10315 /* outputs */
10316 {
10317 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
10318 calloc(1, sizeof(struct _ssPortOutputs));
10319 ss_VALIDATE_MEMORY(rts,outputPortInfo);
10320 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
10321 _ssSetNumOutputPorts(childS, 1);
10322
10323 /* port 0 */
10324 {
10325 _ssSetOutputPortNumDimensions(childS, 0, 1);
10326 ssSetOutputPortWidth(childS, 0, 1);
10327 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
10328 ssGetLocalBlockIO(rts))->Saturation8));
10329 }
10330 }
10331
10332 /* path info */
10333 _ssSetModelName(childS, "IntegratorLimited_sf");
10334 _ssSetPath(childS,
10335 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/Integrator Limited1/Generated S-Function3");
10336 if (ssGetRTModel(rts) == (NULL)) {
10337 _ssSetParentSS(childS, rts);
10338 _ssSetRootSS(childS, ssGetRootSS(rts));
10339 } else {
10340 ssSetRTModel(childS,ssGetRTModel(rts));
10341 _ssSetParentSS(childS, (NULL));
10342 _ssSetRootSS(childS, childS);
10343 }
10344
10345 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
10346
10347 /* work vectors */
10348 {
10349 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
10350 (4 * sizeof(struct _ssDWorkRecord));
10351 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
10352 calloc(4, sizeof(struct _ssDWorkAuxRecord));
10353 ss_VALIDATE_MEMORY(rts,dWorkRecord);
10354 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
10355 ssSetSFcnDWork(childS, dWorkRecord);
10356 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
10357 _ssSetNumDWork(childS, 4);
10358
10359 /* DWORK0 */
10360 ssSetDWorkWidth(childS, 0, 1);
10361 ssSetDWorkDataType(childS, 0,SS_SINGLE);
10362 ssSetDWorkComplexSignal(childS, 0, 0);
10363 ssSetDWorkUsedAsDState(childS, 0, 1);
10364 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 176))[0]);
10365
10366 /* DWORK1 */
10367 ssSetDWorkWidth(childS, 1, 1);
10368 ssSetDWorkDataType(childS, 1,SS_SINGLE);
10369 ssSetDWorkComplexSignal(childS, 1, 0);
10370 ssSetDWorkUsedAsDState(childS, 1, 1);
10371 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 177))[0]);
10372
10373 /* DWORK2 */
10374 ssSetDWorkWidth(childS, 2, 1);
10375 ssSetDWorkDataType(childS, 2,SS_INT8);
10376 ssSetDWorkComplexSignal(childS, 2, 0);
10377 ssSetDWorkUsedAsDState(childS, 2, 1);
10378 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 403))[0]);
10379
10380 /* DWORK3 */
10381 ssSetDWorkWidth(childS, 3, 1);
10382 ssSetDWorkDataType(childS, 3,SS_INT8);
10383 ssSetDWorkComplexSignal(childS, 3, 0);
10384 ssSetDWorkUsedAsDState(childS, 3, 1);
10385 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 404))[0]);
10386 }
10387
10388 (childS)->regDataType.arg1 = ((void *)(childS));
10389 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
10390 FcnSetErrorStatus);
10391 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
10392 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
10393 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
10394 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
10395
10396 /* registration */
10397#if defined(MATLAB_MEX_FILE)
10398
10399 {
10400 int_T i;
10401 mxArray *plhs[1];
10402 mxArray *prhs[4];
10403 double *pr;
10404 volatile int_T *intS = (int_T *)&childS;
10405 int_T addrlen = sizeof(SimStruct *);
10406 int_T m = addrlen/sizeof(int_T) + 1;
10407 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
10408 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
10409 pr = mxGetPr(prhs[1]);
10410 for (i = 0; i < m - 1; i++) {
10411 pr[i] = (double)intS[i];
10412 }
10413
10414 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
10415 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
10416 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
10417
10418 /* Reset port dimensions info functions because the S-function
10419 * and accelerator mex-files explicitly set their dimensions,
10420 * i.e., they are not dynamically sized. For this case, the
10421 * mex-file is responsible for the dimensions info memory
10422 * and Simulink should not free it. This is achieved by
10423 * setting the following two methods to NULL.
10424 */
10425 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
10426 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
10427
10428 /*
10429 * Setup function pointers and call mdlInitializeSizes via
10430 * simulink.c
10431 */
10432 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
10433 mxDestroyArray(plhs[0]);
10434 mxDestroyArray(prhs[0]);
10435 mxDestroyArray(prhs[1]);
10436 mxDestroyArray(prhs[2]);
10437 mxDestroyArray(prhs[3]);
10438 }
10439
10440#else
10441
10442 {
10443 IntegratorLimited_sf(childS);
10444 sfcnInitializeSizes(childS);
10445 }
10446
10447#endif
10448
10449 sfcnInitializeSampleTimes(childS);
10450
10451 /* adjust sample time */
10452 ssSetSampleTime(childS, 0, 0.0);
10453 ssSetOffsetTime(childS, 0, 0.0);
10454 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
10455
10456 /* set compiled values of dynamic vector attributes */
10457 ssSetNumNonsampledZCs(childS, 0);
10458
10459 /* Update connectivity flags for each port */
10460 _ssSetInputPortConnected(childS, 0, 1);
10461 _ssSetInputPortConnected(childS, 1, 1);
10462 _ssSetInputPortConnected(childS, 2, 1);
10463 _ssSetInputPortConnected(childS, 3, 1);
10464 _ssSetInputPortConnected(childS, 4, 1);
10465 _ssSetInputPortConnected(childS, 5, 1);
10466 _ssSetInputPortConnected(childS, 6, 1);
10467 _ssSetOutputPortConnected(childS, 0, 1);
10468 _ssSetOutputPortBeingMerged(childS, 0, 0);
10469
10470 /* Update the BufferDstPort flags for each input port */
10471 _ssSetInputPortBufferDstPort(childS, 0, -1);
10472 _ssSetInputPortBufferDstPort(childS, 1, -1);
10473 _ssSetInputPortBufferDstPort(childS, 2, -1);
10474 _ssSetInputPortBufferDstPort(childS, 3, -1);
10475 _ssSetInputPortBufferDstPort(childS, 4, -1);
10476 _ssSetInputPortBufferDstPort(childS, 5, -1);
10477 _ssSetInputPortBufferDstPort(childS, 6, -1);
10478 }
10479
10480 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S101>/Generated S-Function2 (LeadLagFilter_sf) */
10481 {
10482 SimStruct *childS = ssGetSFunction(rts, 39);
10483
10484 /* timing info */
10485 time_T *sfcnPeriod;
10486 time_T *sfcnOffset;
10487 int_T *sfcnTsMap;
10488 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
10489 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
10490 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
10491 ss_VALIDATE_MEMORY(rts,sfcnOffset);
10492 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
10493 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
10494 (void) memset((void*)sfcnPeriod, 0,
10495 sizeof(time_T)*1);
10496 (void) memset((void*)sfcnOffset, 0,
10497 sizeof(time_T)*1);
10498 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
10499 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
10500 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
10501
10502 /* Set up the mdlInfo pointer */
10503# ifdef USE_RTMODEL
10504
10505 {
10506 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
10507 struct _ssBlkInfo2));
10508 ss_VALIDATE_MEMORY(rts,blkInfo2);
10509 ssSetBlkInfo2Ptr(childS, blkInfo2);
10510 }
10511
10512 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
10513
10514# else
10515
10516 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
10517
10518# endif /* USE_RTMODEL */
10519
10520 /* Allocate memory of model methods 2 */
10521 {
10522 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
10523 malloc(sizeof(struct _ssSFcnModelMethods2));
10524 ss_VALIDATE_MEMORY(rts,methods2);
10525 ssSetModelMethods2(childS, methods2);
10526 }
10527
10528 /* Allocate memory of model methods 3 */
10529 {
10530 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
10531 malloc(sizeof(struct _ssSFcnModelMethods3));
10532 ss_VALIDATE_MEMORY(rts,methods3);
10533 ssSetModelMethods3(childS, methods3);
10534 }
10535
10536 /* Allocate memory for states auxilliary information */
10537 {
10538 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
10539 (sizeof(struct _ssStatesInfo2));
10540 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
10541 malloc(sizeof(ssPeriodicStatesInfo));
10542 ss_VALIDATE_MEMORY(rts,statesInfo2);
10543 ssSetStatesInfo2(childS, statesInfo2);
10544 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
10545 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
10546 }
10547
10548 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
10549 RegNumInputPorts);
10550 ssSetRegNumInputPortsFcnArg(childS,childS);
10551
10552 /* inputs */
10553 {
10554 struct _ssPortInputs *inputPortInfo =
10555 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
10556 ss_VALIDATE_MEMORY(rts,inputPortInfo);
10557 _ssSetNumInputPorts(childS, 7);
10558 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
10559
10560 /* port 0 */
10561 {
10562 real32_T const **sfcnUPtrs = (real32_T const **)
10563 malloc(1 * sizeof(real32_T *));
10564 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10565 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10566 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
10567 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
10568 _ssSetInputPortNumDimensions(childS, 0, 1);
10569 ssSetInputPortWidth(childS, 0, 1);
10570 }
10571
10572 /* port 1 */
10573 {
10574 int8_T const **sfcnUPtrs = (int8_T const **)
10575 malloc(1 * sizeof(int8_T *));
10576 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10577 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
10578 ssGetLocalBlockIO(rts))->DataTypeConversion2_c;
10579 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
10580 _ssSetInputPortNumDimensions(childS, 1, 1);
10581 ssSetInputPortWidth(childS, 1, 1);
10582 }
10583
10584 /* port 2 */
10585 {
10586 real32_T const **sfcnUPtrs = (real32_T const **)
10587 malloc(1 * sizeof(real32_T *));
10588 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10589 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
10590 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
10591 _ssSetInputPortNumDimensions(childS, 2, 1);
10592 ssSetInputPortWidth(childS, 2, 1);
10593 }
10594
10595 /* port 3 */
10596 {
10597 real32_T const **sfcnUPtrs = (real32_T const **)
10598 malloc(1 * sizeof(real32_T *));
10599 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10600 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;
10601 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
10602 _ssSetInputPortNumDimensions(childS, 3, 1);
10603 ssSetInputPortWidth(childS, 3, 1);
10604 }
10605
10606 /* port 4 */
10607 {
10608 real32_T const **sfcnUPtrs = (real32_T const **)
10609 malloc(1 * sizeof(real32_T *));
10610 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10611 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10612 ssGetLocalBlockIO(rts))->Switch_aj;
10613 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
10614 _ssSetInputPortNumDimensions(childS, 4, 1);
10615 ssSetInputPortWidth(childS, 4, 1);
10616 }
10617
10618 /* port 5 */
10619 {
10620 real32_T const **sfcnUPtrs = (real32_T const **)
10621 malloc(1 * sizeof(real32_T *));
10622 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10623 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10624 ssGetLocalBlockIO(rts))->Switch_aj;
10625 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
10626 _ssSetInputPortNumDimensions(childS, 5, 1);
10627 ssSetInputPortWidth(childS, 5, 1);
10628 }
10629
10630 /* port 6 */
10631 {
10632 real32_T const **sfcnUPtrs = (real32_T const **)
10633 malloc(1 * sizeof(real32_T *));
10634 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10635 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10636 ssGetLocalBlockIO(rts))->Divide_e;
10637 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
10638 _ssSetInputPortNumDimensions(childS, 6, 1);
10639 ssSetInputPortWidth(childS, 6, 1);
10640 }
10641 }
10642
10643 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
10644 RegNumOutputPorts);
10645 ssSetRegNumOutputPortsFcnArg(childS,childS);
10646
10647 /* outputs */
10648 {
10649 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
10650 calloc(1, sizeof(struct _ssPortOutputs));
10651 ss_VALIDATE_MEMORY(rts,outputPortInfo);
10652 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
10653 _ssSetNumOutputPorts(childS, 1);
10654
10655 /* port 0 */
10656 {
10657 _ssSetOutputPortNumDimensions(childS, 0, 1);
10658 ssSetOutputPortWidth(childS, 0, 1);
10659 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
10660 ssGetLocalBlockIO(rts))->GeneratedSFunction2_j));
10661 }
10662 }
10663
10664 /* path info */
10665 _ssSetModelName(childS, "LeadLagFilter_sf");
10666 _ssSetPath(childS,
10667 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/Lead lag/Generated S-Function2");
10668 if (ssGetRTModel(rts) == (NULL)) {
10669 _ssSetParentSS(childS, rts);
10670 _ssSetRootSS(childS, ssGetRootSS(rts));
10671 } else {
10672 ssSetRTModel(childS,ssGetRTModel(rts));
10673 _ssSetParentSS(childS, (NULL));
10674 _ssSetRootSS(childS, childS);
10675 }
10676
10677 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
10678
10679 /* work vectors */
10680 {
10681 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
10682 (4 * sizeof(struct _ssDWorkRecord));
10683 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
10684 calloc(4, sizeof(struct _ssDWorkAuxRecord));
10685 ss_VALIDATE_MEMORY(rts,dWorkRecord);
10686 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
10687 ssSetSFcnDWork(childS, dWorkRecord);
10688 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
10689 _ssSetNumDWork(childS, 4);
10690
10691 /* DWORK0 */
10692 ssSetDWorkWidth(childS, 0, 1);
10693 ssSetDWorkDataType(childS, 0,SS_SINGLE);
10694 ssSetDWorkComplexSignal(childS, 0, 0);
10695 ssSetDWorkUsedAsDState(childS, 0, 1);
10696 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 178))[0]);
10697
10698 /* DWORK1 */
10699 ssSetDWorkWidth(childS, 1, 1);
10700 ssSetDWorkDataType(childS, 1,SS_SINGLE);
10701 ssSetDWorkComplexSignal(childS, 1, 0);
10702 ssSetDWorkUsedAsDState(childS, 1, 1);
10703 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 179))[0]);
10704
10705 /* DWORK2 */
10706 ssSetDWorkWidth(childS, 2, 1);
10707 ssSetDWorkDataType(childS, 2,SS_INT8);
10708 ssSetDWorkComplexSignal(childS, 2, 0);
10709 ssSetDWorkUsedAsDState(childS, 2, 1);
10710 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 405))[0]);
10711
10712 /* DWORK3 */
10713 ssSetDWorkWidth(childS, 3, 1);
10714 ssSetDWorkDataType(childS, 3,SS_INT8);
10715 ssSetDWorkComplexSignal(childS, 3, 0);
10716 ssSetDWorkUsedAsDState(childS, 3, 1);
10717 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 406))[0]);
10718 }
10719
10720 (childS)->regDataType.arg1 = ((void *)(childS));
10721 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
10722 FcnSetErrorStatus);
10723 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
10724 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
10725 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
10726 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
10727
10728 /* registration */
10729#if defined(MATLAB_MEX_FILE)
10730
10731 {
10732 int_T i;
10733 mxArray *plhs[1];
10734 mxArray *prhs[4];
10735 double *pr;
10736 volatile int_T *intS = (int_T *)&childS;
10737 int_T addrlen = sizeof(SimStruct *);
10738 int_T m = addrlen/sizeof(int_T) + 1;
10739 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
10740 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
10741 pr = mxGetPr(prhs[1]);
10742 for (i = 0; i < m - 1; i++) {
10743 pr[i] = (double)intS[i];
10744 }
10745
10746 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
10747 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
10748 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
10749
10750 /* Reset port dimensions info functions because the S-function
10751 * and accelerator mex-files explicitly set their dimensions,
10752 * i.e., they are not dynamically sized. For this case, the
10753 * mex-file is responsible for the dimensions info memory
10754 * and Simulink should not free it. This is achieved by
10755 * setting the following two methods to NULL.
10756 */
10757 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
10758 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
10759
10760 /*
10761 * Setup function pointers and call mdlInitializeSizes via
10762 * simulink.c
10763 */
10764 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
10765 mxDestroyArray(plhs[0]);
10766 mxDestroyArray(prhs[0]);
10767 mxDestroyArray(prhs[1]);
10768 mxDestroyArray(prhs[2]);
10769 mxDestroyArray(prhs[3]);
10770 }
10771
10772#else
10773
10774 {
10775 LeadLagFilter_sf(childS);
10776 sfcnInitializeSizes(childS);
10777 }
10778
10779#endif
10780
10781 sfcnInitializeSampleTimes(childS);
10782
10783 /* adjust sample time */
10784 ssSetSampleTime(childS, 0, 0.0);
10785 ssSetOffsetTime(childS, 0, 0.0);
10786 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
10787
10788 /* set compiled values of dynamic vector attributes */
10789 ssSetNumNonsampledZCs(childS, 0);
10790
10791 /* Update connectivity flags for each port */
10792 _ssSetInputPortConnected(childS, 0, 1);
10793 _ssSetInputPortConnected(childS, 1, 1);
10794 _ssSetInputPortConnected(childS, 2, 1);
10795 _ssSetInputPortConnected(childS, 3, 1);
10796 _ssSetInputPortConnected(childS, 4, 1);
10797 _ssSetInputPortConnected(childS, 5, 1);
10798 _ssSetInputPortConnected(childS, 6, 1);
10799 _ssSetOutputPortConnected(childS, 0, 1);
10800 _ssSetOutputPortBeingMerged(childS, 0, 0);
10801
10802 /* Update the BufferDstPort flags for each input port */
10803 _ssSetInputPortBufferDstPort(childS, 0, -1);
10804 _ssSetInputPortBufferDstPort(childS, 1, -1);
10805 _ssSetInputPortBufferDstPort(childS, 2, -1);
10806 _ssSetInputPortBufferDstPort(childS, 3, -1);
10807 _ssSetInputPortBufferDstPort(childS, 4, -1);
10808 _ssSetInputPortBufferDstPort(childS, 5, -1);
10809 _ssSetInputPortBufferDstPort(childS, 6, -1);
10810 }
10811
10812 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S103>/Generated S-Function1 (SaturationLimiter_sf) */
10813 {
10814 SimStruct *childS = ssGetSFunction(rts, 40);
10815
10816 /* timing info */
10817 time_T *sfcnPeriod;
10818 time_T *sfcnOffset;
10819 int_T *sfcnTsMap;
10820 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
10821 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
10822 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
10823 ss_VALIDATE_MEMORY(rts,sfcnOffset);
10824 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
10825 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
10826 (void) memset((void*)sfcnPeriod, 0,
10827 sizeof(time_T)*1);
10828 (void) memset((void*)sfcnOffset, 0,
10829 sizeof(time_T)*1);
10830 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
10831 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
10832 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
10833
10834 /* Set up the mdlInfo pointer */
10835# ifdef USE_RTMODEL
10836
10837 {
10838 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
10839 struct _ssBlkInfo2));
10840 ss_VALIDATE_MEMORY(rts,blkInfo2);
10841 ssSetBlkInfo2Ptr(childS, blkInfo2);
10842 }
10843
10844 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
10845
10846# else
10847
10848 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
10849
10850# endif /* USE_RTMODEL */
10851
10852 /* Allocate memory of model methods 2 */
10853 {
10854 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
10855 malloc(sizeof(struct _ssSFcnModelMethods2));
10856 ss_VALIDATE_MEMORY(rts,methods2);
10857 ssSetModelMethods2(childS, methods2);
10858 }
10859
10860 /* Allocate memory of model methods 3 */
10861 {
10862 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
10863 malloc(sizeof(struct _ssSFcnModelMethods3));
10864 ss_VALIDATE_MEMORY(rts,methods3);
10865 ssSetModelMethods3(childS, methods3);
10866 }
10867
10868 /* Allocate memory for states auxilliary information */
10869 {
10870 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
10871 (sizeof(struct _ssStatesInfo2));
10872 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
10873 malloc(sizeof(ssPeriodicStatesInfo));
10874 ss_VALIDATE_MEMORY(rts,statesInfo2);
10875 ssSetStatesInfo2(childS, statesInfo2);
10876 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
10877 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
10878 }
10879
10880 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
10881 RegNumInputPorts);
10882 ssSetRegNumInputPortsFcnArg(childS,childS);
10883
10884 /* inputs */
10885 {
10886 struct _ssPortInputs *inputPortInfo =
10887 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
10888 ss_VALIDATE_MEMORY(rts,inputPortInfo);
10889 _ssSetNumInputPorts(childS, 3);
10890 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
10891
10892 /* port 0 */
10893 {
10894 real32_T const **sfcnUPtrs = (real32_T const **)
10895 malloc(1 * sizeof(real32_T *));
10896 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10897 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10898 ssGetLocalBlockIO(rts))->GeneratedSFunction2_j;
10899 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
10900 _ssSetInputPortNumDimensions(childS, 0, 1);
10901 ssSetInputPortWidth(childS, 0, 1);
10902 }
10903
10904 /* port 1 */
10905 {
10906 real32_T const **sfcnUPtrs = (real32_T const **)
10907 malloc(1 * sizeof(real32_T *));
10908 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10909 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10910 ssGetLocalBlockIO(rts))->Product1_m;
10911 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
10912 _ssSetInputPortNumDimensions(childS, 1, 1);
10913 ssSetInputPortWidth(childS, 1, 1);
10914 }
10915
10916 /* port 2 */
10917 {
10918 real32_T const **sfcnUPtrs = (real32_T const **)
10919 malloc(1 * sizeof(real32_T *));
10920 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
10921 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
10922 ssGetLocalBlockIO(rts))->Product_pp;
10923 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
10924 _ssSetInputPortNumDimensions(childS, 2, 1);
10925 ssSetInputPortWidth(childS, 2, 1);
10926 }
10927 }
10928
10929 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
10930 RegNumOutputPorts);
10931 ssSetRegNumOutputPortsFcnArg(childS,childS);
10932
10933 /* outputs */
10934 {
10935 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
10936 calloc(1, sizeof(struct _ssPortOutputs));
10937 ss_VALIDATE_MEMORY(rts,outputPortInfo);
10938 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
10939 _ssSetNumOutputPorts(childS, 1);
10940
10941 /* port 0 */
10942 {
10943 _ssSetOutputPortNumDimensions(childS, 0, 1);
10944 ssSetOutputPortWidth(childS, 0, 1);
10945 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
10946 ssGetLocalBlockIO(rts))->GeneratedSFunction1_e));
10947 }
10948 }
10949
10950 /* path info */
10951 _ssSetModelName(childS, "SaturationLimiter_sf");
10952 _ssSetPath(childS,
10953 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/Saturation Limiter2/Generated S-Function1");
10954 if (ssGetRTModel(rts) == (NULL)) {
10955 _ssSetParentSS(childS, rts);
10956 _ssSetRootSS(childS, ssGetRootSS(rts));
10957 } else {
10958 ssSetRTModel(childS,ssGetRTModel(rts));
10959 _ssSetParentSS(childS, (NULL));
10960 _ssSetRootSS(childS, childS);
10961 }
10962
10963 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
10964 (childS)->regDataType.arg1 = ((void *)(childS));
10965 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
10966 FcnSetErrorStatus);
10967 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
10968 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
10969 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
10970 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
10971
10972 /* registration */
10973#if defined(MATLAB_MEX_FILE)
10974
10975 {
10976 int_T i;
10977 mxArray *plhs[1];
10978 mxArray *prhs[4];
10979 double *pr;
10980 volatile int_T *intS = (int_T *)&childS;
10981 int_T addrlen = sizeof(SimStruct *);
10982 int_T m = addrlen/sizeof(int_T) + 1;
10983 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
10984 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
10985 pr = mxGetPr(prhs[1]);
10986 for (i = 0; i < m - 1; i++) {
10987 pr[i] = (double)intS[i];
10988 }
10989
10990 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
10991 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
10992 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
10993
10994 /* Reset port dimensions info functions because the S-function
10995 * and accelerator mex-files explicitly set their dimensions,
10996 * i.e., they are not dynamically sized. For this case, the
10997 * mex-file is responsible for the dimensions info memory
10998 * and Simulink should not free it. This is achieved by
10999 * setting the following two methods to NULL.
11000 */
11001 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
11002 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
11003
11004 /*
11005 * Setup function pointers and call mdlInitializeSizes via
11006 * simulink.c
11007 */
11008 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
11009 mxDestroyArray(plhs[0]);
11010 mxDestroyArray(prhs[0]);
11011 mxDestroyArray(prhs[1]);
11012 mxDestroyArray(prhs[2]);
11013 mxDestroyArray(prhs[3]);
11014 }
11015
11016#else
11017
11018 {
11019 SaturationLimiter_sf(childS);
11020 sfcnInitializeSizes(childS);
11021 }
11022
11023#endif
11024
11025 sfcnInitializeSampleTimes(childS);
11026
11027 /* adjust sample time */
11028 ssSetSampleTime(childS, 0, 0.0);
11029 ssSetOffsetTime(childS, 0, 0.0);
11030 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
11031
11032 /* set compiled values of dynamic vector attributes */
11033 ssSetNumNonsampledZCs(childS, 0);
11034
11035 /* Update connectivity flags for each port */
11036 _ssSetInputPortConnected(childS, 0, 1);
11037 _ssSetInputPortConnected(childS, 1, 1);
11038 _ssSetInputPortConnected(childS, 2, 1);
11039 _ssSetOutputPortConnected(childS, 0, 1);
11040 _ssSetOutputPortBeingMerged(childS, 0, 0);
11041
11042 /* Update the BufferDstPort flags for each input port */
11043 _ssSetInputPortBufferDstPort(childS, 0, -1);
11044 _ssSetInputPortBufferDstPort(childS, 1, -1);
11045 _ssSetInputPortBufferDstPort(childS, 2, -1);
11046 }
11047
11048 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S98>/Generated S-Function4 (LagFilter_sf) */
11049 {
11050 SimStruct *childS = ssGetSFunction(rts, 41);
11051
11052 /* timing info */
11053 time_T *sfcnPeriod;
11054 time_T *sfcnOffset;
11055 int_T *sfcnTsMap;
11056 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
11057 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
11058 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
11059 ss_VALIDATE_MEMORY(rts,sfcnOffset);
11060 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
11061 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
11062 (void) memset((void*)sfcnPeriod, 0,
11063 sizeof(time_T)*1);
11064 (void) memset((void*)sfcnOffset, 0,
11065 sizeof(time_T)*1);
11066 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
11067 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
11068 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
11069
11070 /* Set up the mdlInfo pointer */
11071# ifdef USE_RTMODEL
11072
11073 {
11074 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
11075 struct _ssBlkInfo2));
11076 ss_VALIDATE_MEMORY(rts,blkInfo2);
11077 ssSetBlkInfo2Ptr(childS, blkInfo2);
11078 }
11079
11080 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
11081
11082# else
11083
11084 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
11085
11086# endif /* USE_RTMODEL */
11087
11088 /* Allocate memory of model methods 2 */
11089 {
11090 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
11091 malloc(sizeof(struct _ssSFcnModelMethods2));
11092 ss_VALIDATE_MEMORY(rts,methods2);
11093 ssSetModelMethods2(childS, methods2);
11094 }
11095
11096 /* Allocate memory of model methods 3 */
11097 {
11098 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
11099 malloc(sizeof(struct _ssSFcnModelMethods3));
11100 ss_VALIDATE_MEMORY(rts,methods3);
11101 ssSetModelMethods3(childS, methods3);
11102 }
11103
11104 /* Allocate memory for states auxilliary information */
11105 {
11106 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
11107 (sizeof(struct _ssStatesInfo2));
11108 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
11109 malloc(sizeof(ssPeriodicStatesInfo));
11110 ss_VALIDATE_MEMORY(rts,statesInfo2);
11111 ssSetStatesInfo2(childS, statesInfo2);
11112 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
11113 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
11114 }
11115
11116 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
11117 RegNumInputPorts);
11118 ssSetRegNumInputPortsFcnArg(childS,childS);
11119
11120 /* inputs */
11121 {
11122 struct _ssPortInputs *inputPortInfo =
11123 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
11124 ss_VALIDATE_MEMORY(rts,inputPortInfo);
11125 _ssSetNumInputPorts(childS, 6);
11126 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
11127
11128 /* port 0 */
11129 {
11130 real32_T const **sfcnUPtrs = (real32_T const **)
11131 malloc(1 * sizeof(real32_T *));
11132 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11133 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
11134 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
11135 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
11136 _ssSetInputPortNumDimensions(childS, 0, 1);
11137 ssSetInputPortWidth(childS, 0, 1);
11138 }
11139
11140 /* port 1 */
11141 {
11142 int8_T const **sfcnUPtrs = (int8_T const **)
11143 malloc(1 * sizeof(int8_T *));
11144 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11145 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
11146 ssGetLocalBlockIO(rts))->DataTypeConversion2_c;
11147 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
11148 _ssSetInputPortNumDimensions(childS, 1, 1);
11149 ssSetInputPortWidth(childS, 1, 1);
11150 }
11151
11152 /* port 2 */
11153 {
11154 real32_T const **sfcnUPtrs = (real32_T const **)
11155 malloc(1 * sizeof(real32_T *));
11156 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11157 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
11158 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
11159 _ssSetInputPortNumDimensions(childS, 2, 1);
11160 ssSetInputPortWidth(childS, 2, 1);
11161 }
11162
11163 /* port 3 */
11164 {
11165 real32_T const **sfcnUPtrs = (real32_T const **)
11166 malloc(1 * sizeof(real32_T *));
11167 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11168 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
11169 ssGetLocalBlockIO(rts))->Switch_aj;
11170 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
11171 _ssSetInputPortNumDimensions(childS, 3, 1);
11172 ssSetInputPortWidth(childS, 3, 1);
11173 }
11174
11175 /* port 4 */
11176 {
11177 real32_T const **sfcnUPtrs = (real32_T const **)
11178 malloc(1 * sizeof(real32_T *));
11179 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11180 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
11181 ssGetLocalBlockIO(rts))->Switch_aj;
11182 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
11183 _ssSetInputPortNumDimensions(childS, 4, 1);
11184 ssSetInputPortWidth(childS, 4, 1);
11185 }
11186
11187 /* port 5 */
11188 {
11189 real32_T const **sfcnUPtrs = (real32_T const **)
11190 malloc(1 * sizeof(real32_T *));
11191 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11192 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
11193 ssGetLocalBlockIO(rts))->GeneratedSFunction1_e;
11194 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
11195 _ssSetInputPortNumDimensions(childS, 5, 1);
11196 ssSetInputPortWidth(childS, 5, 1);
11197 }
11198 }
11199
11200 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
11201 RegNumOutputPorts);
11202 ssSetRegNumOutputPortsFcnArg(childS,childS);
11203
11204 /* outputs */
11205 {
11206 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
11207 calloc(1, sizeof(struct _ssPortOutputs));
11208 ss_VALIDATE_MEMORY(rts,outputPortInfo);
11209 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
11210 _ssSetNumOutputPorts(childS, 1);
11211
11212 /* port 0 */
11213 {
11214 _ssSetOutputPortNumDimensions(childS, 0, 1);
11215 ssSetOutputPortWidth(childS, 0, 1);
11216 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
11217 ssGetLocalBlockIO(rts))->GeneratedSFunction4_c));
11218 }
11219 }
11220
11221 /* path info */
11222 _ssSetModelName(childS, "LagFilter_sf");
11223 _ssSetPath(childS,
11224 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/GamaLControl/ lag filter/Generated S-Function4");
11225 if (ssGetRTModel(rts) == (NULL)) {
11226 _ssSetParentSS(childS, rts);
11227 _ssSetRootSS(childS, ssGetRootSS(rts));
11228 } else {
11229 ssSetRTModel(childS,ssGetRTModel(rts));
11230 _ssSetParentSS(childS, (NULL));
11231 _ssSetRootSS(childS, childS);
11232 }
11233
11234 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
11235
11236 /* work vectors */
11237 {
11238 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
11239 (4 * sizeof(struct _ssDWorkRecord));
11240 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
11241 calloc(4, sizeof(struct _ssDWorkAuxRecord));
11242 ss_VALIDATE_MEMORY(rts,dWorkRecord);
11243 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
11244 ssSetSFcnDWork(childS, dWorkRecord);
11245 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
11246 _ssSetNumDWork(childS, 4);
11247
11248 /* DWORK0 */
11249 ssSetDWorkWidth(childS, 0, 1);
11250 ssSetDWorkDataType(childS, 0,SS_SINGLE);
11251 ssSetDWorkComplexSignal(childS, 0, 0);
11252 ssSetDWorkUsedAsDState(childS, 0, 1);
11253 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 180))[0]);
11254
11255 /* DWORK1 */
11256 ssSetDWorkWidth(childS, 1, 1);
11257 ssSetDWorkDataType(childS, 1,SS_SINGLE);
11258 ssSetDWorkComplexSignal(childS, 1, 0);
11259 ssSetDWorkUsedAsDState(childS, 1, 1);
11260 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 181))[0]);
11261
11262 /* DWORK2 */
11263 ssSetDWorkWidth(childS, 2, 1);
11264 ssSetDWorkDataType(childS, 2,SS_INT8);
11265 ssSetDWorkComplexSignal(childS, 2, 0);
11266 ssSetDWorkUsedAsDState(childS, 2, 1);
11267 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 407))[0]);
11268
11269 /* DWORK3 */
11270 ssSetDWorkWidth(childS, 3, 1);
11271 ssSetDWorkDataType(childS, 3,SS_INT8);
11272 ssSetDWorkComplexSignal(childS, 3, 0);
11273 ssSetDWorkUsedAsDState(childS, 3, 1);
11274 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 408))[0]);
11275 }
11276
11277 (childS)->regDataType.arg1 = ((void *)(childS));
11278 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
11279 FcnSetErrorStatus);
11280 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
11281 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
11282 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
11283 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
11284
11285 /* registration */
11286#if defined(MATLAB_MEX_FILE)
11287
11288 {
11289 int_T i;
11290 mxArray *plhs[1];
11291 mxArray *prhs[4];
11292 double *pr;
11293 volatile int_T *intS = (int_T *)&childS;
11294 int_T addrlen = sizeof(SimStruct *);
11295 int_T m = addrlen/sizeof(int_T) + 1;
11296 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
11297 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
11298 pr = mxGetPr(prhs[1]);
11299 for (i = 0; i < m - 1; i++) {
11300 pr[i] = (double)intS[i];
11301 }
11302
11303 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
11304 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
11305 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
11306
11307 /* Reset port dimensions info functions because the S-function
11308 * and accelerator mex-files explicitly set their dimensions,
11309 * i.e., they are not dynamically sized. For this case, the
11310 * mex-file is responsible for the dimensions info memory
11311 * and Simulink should not free it. This is achieved by
11312 * setting the following two methods to NULL.
11313 */
11314 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
11315 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
11316
11317 /*
11318 * Setup function pointers and call mdlInitializeSizes via
11319 * simulink.c
11320 */
11321 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
11322 mxDestroyArray(plhs[0]);
11323 mxDestroyArray(prhs[0]);
11324 mxDestroyArray(prhs[1]);
11325 mxDestroyArray(prhs[2]);
11326 mxDestroyArray(prhs[3]);
11327 }
11328
11329#else
11330
11331 {
11332 LagFilter_sf(childS);
11333 sfcnInitializeSizes(childS);
11334 }
11335
11336#endif
11337
11338 sfcnInitializeSampleTimes(childS);
11339
11340 /* adjust sample time */
11341 ssSetSampleTime(childS, 0, 0.0);
11342 ssSetOffsetTime(childS, 0, 0.0);
11343 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
11344
11345 /* set compiled values of dynamic vector attributes */
11346 ssSetNumNonsampledZCs(childS, 0);
11347
11348 /* Update connectivity flags for each port */
11349 _ssSetInputPortConnected(childS, 0, 1);
11350 _ssSetInputPortConnected(childS, 1, 1);
11351 _ssSetInputPortConnected(childS, 2, 1);
11352 _ssSetInputPortConnected(childS, 3, 1);
11353 _ssSetInputPortConnected(childS, 4, 1);
11354 _ssSetInputPortConnected(childS, 5, 1);
11355 _ssSetOutputPortConnected(childS, 0, 1);
11356 _ssSetOutputPortBeingMerged(childS, 0, 0);
11357
11358 /* Update the BufferDstPort flags for each input port */
11359 _ssSetInputPortBufferDstPort(childS, 0, -1);
11360 _ssSetInputPortBufferDstPort(childS, 1, -1);
11361 _ssSetInputPortBufferDstPort(childS, 2, -1);
11362 _ssSetInputPortBufferDstPort(childS, 3, -1);
11363 _ssSetInputPortBufferDstPort(childS, 4, -1);
11364 _ssSetInputPortBufferDstPort(childS, 5, -1);
11365 }
11366
11367 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S109>/Generated S-Function1 (SaturationLimiter_sf) */
11368 {
11369 SimStruct *childS = ssGetSFunction(rts, 42);
11370
11371 /* timing info */
11372 time_T *sfcnPeriod;
11373 time_T *sfcnOffset;
11374 int_T *sfcnTsMap;
11375 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
11376 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
11377 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
11378 ss_VALIDATE_MEMORY(rts,sfcnOffset);
11379 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
11380 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
11381 (void) memset((void*)sfcnPeriod, 0,
11382 sizeof(time_T)*1);
11383 (void) memset((void*)sfcnOffset, 0,
11384 sizeof(time_T)*1);
11385 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
11386 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
11387 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
11388
11389 /* Set up the mdlInfo pointer */
11390# ifdef USE_RTMODEL
11391
11392 {
11393 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
11394 struct _ssBlkInfo2));
11395 ss_VALIDATE_MEMORY(rts,blkInfo2);
11396 ssSetBlkInfo2Ptr(childS, blkInfo2);
11397 }
11398
11399 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
11400
11401# else
11402
11403 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
11404
11405# endif /* USE_RTMODEL */
11406
11407 /* Allocate memory of model methods 2 */
11408 {
11409 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
11410 malloc(sizeof(struct _ssSFcnModelMethods2));
11411 ss_VALIDATE_MEMORY(rts,methods2);
11412 ssSetModelMethods2(childS, methods2);
11413 }
11414
11415 /* Allocate memory of model methods 3 */
11416 {
11417 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
11418 malloc(sizeof(struct _ssSFcnModelMethods3));
11419 ss_VALIDATE_MEMORY(rts,methods3);
11420 ssSetModelMethods3(childS, methods3);
11421 }
11422
11423 /* Allocate memory for states auxilliary information */
11424 {
11425 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
11426 (sizeof(struct _ssStatesInfo2));
11427 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
11428 malloc(sizeof(ssPeriodicStatesInfo));
11429 ss_VALIDATE_MEMORY(rts,statesInfo2);
11430 ssSetStatesInfo2(childS, statesInfo2);
11431 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
11432 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
11433 }
11434
11435 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
11436 RegNumInputPorts);
11437 ssSetRegNumInputPortsFcnArg(childS,childS);
11438
11439 /* inputs */
11440 {
11441 struct _ssPortInputs *inputPortInfo =
11442 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
11443 ss_VALIDATE_MEMORY(rts,inputPortInfo);
11444 _ssSetNumInputPorts(childS, 3);
11445 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
11446
11447 /* port 0 */
11448 {
11449 real32_T const **sfcnUPtrs = (real32_T const **)
11450 malloc(1 * sizeof(real32_T *));
11451 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11452 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
11453 ssGetLocalBlockIO(rts))->Sum1_i;
11454 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
11455 _ssSetInputPortNumDimensions(childS, 0, 1);
11456 ssSetInputPortWidth(childS, 0, 1);
11457 }
11458
11459 /* port 1 */
11460 {
11461 real32_T const **sfcnUPtrs = (real32_T const **)
11462 malloc(1 * sizeof(real32_T *));
11463 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11464 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;
11465 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
11466 _ssSetInputPortNumDimensions(childS, 1, 1);
11467 ssSetInputPortWidth(childS, 1, 1);
11468 }
11469
11470 /* port 2 */
11471 {
11472 real32_T const **sfcnUPtrs = (real32_T const **)
11473 malloc(1 * sizeof(real32_T *));
11474 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11475 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;
11476 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
11477 _ssSetInputPortNumDimensions(childS, 2, 1);
11478 ssSetInputPortWidth(childS, 2, 1);
11479 }
11480 }
11481
11482 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
11483 RegNumOutputPorts);
11484 ssSetRegNumOutputPortsFcnArg(childS,childS);
11485
11486 /* outputs */
11487 {
11488 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
11489 calloc(1, sizeof(struct _ssPortOutputs));
11490 ss_VALIDATE_MEMORY(rts,outputPortInfo);
11491 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
11492 _ssSetNumOutputPorts(childS, 1);
11493
11494 /* port 0 */
11495 {
11496 _ssSetOutputPortNumDimensions(childS, 0, 1);
11497 ssSetOutputPortWidth(childS, 0, 1);
11498 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
11499 ssGetLocalBlockIO(rts))->GeneratedSFunction1_g));
11500 }
11501 }
11502
11503 /* path info */
11504 _ssSetModelName(childS, "SaturationLimiter_sf");
11505 _ssSetPath(childS,
11506 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/Saturation Limiter1/Generated S-Function1");
11507 if (ssGetRTModel(rts) == (NULL)) {
11508 _ssSetParentSS(childS, rts);
11509 _ssSetRootSS(childS, ssGetRootSS(rts));
11510 } else {
11511 ssSetRTModel(childS,ssGetRTModel(rts));
11512 _ssSetParentSS(childS, (NULL));
11513 _ssSetRootSS(childS, childS);
11514 }
11515
11516 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
11517 (childS)->regDataType.arg1 = ((void *)(childS));
11518 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
11519 FcnSetErrorStatus);
11520 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
11521 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
11522 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
11523 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
11524
11525 /* registration */
11526#if defined(MATLAB_MEX_FILE)
11527
11528 {
11529 int_T i;
11530 mxArray *plhs[1];
11531 mxArray *prhs[4];
11532 double *pr;
11533 volatile int_T *intS = (int_T *)&childS;
11534 int_T addrlen = sizeof(SimStruct *);
11535 int_T m = addrlen/sizeof(int_T) + 1;
11536 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
11537 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
11538 pr = mxGetPr(prhs[1]);
11539 for (i = 0; i < m - 1; i++) {
11540 pr[i] = (double)intS[i];
11541 }
11542
11543 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
11544 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
11545 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
11546
11547 /* Reset port dimensions info functions because the S-function
11548 * and accelerator mex-files explicitly set their dimensions,
11549 * i.e., they are not dynamically sized. For this case, the
11550 * mex-file is responsible for the dimensions info memory
11551 * and Simulink should not free it. This is achieved by
11552 * setting the following two methods to NULL.
11553 */
11554 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
11555 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
11556
11557 /*
11558 * Setup function pointers and call mdlInitializeSizes via
11559 * simulink.c
11560 */
11561 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
11562 mxDestroyArray(plhs[0]);
11563 mxDestroyArray(prhs[0]);
11564 mxDestroyArray(prhs[1]);
11565 mxDestroyArray(prhs[2]);
11566 mxDestroyArray(prhs[3]);
11567 }
11568
11569#else
11570
11571 {
11572 SaturationLimiter_sf(childS);
11573 sfcnInitializeSizes(childS);
11574 }
11575
11576#endif
11577
11578 sfcnInitializeSampleTimes(childS);
11579
11580 /* adjust sample time */
11581 ssSetSampleTime(childS, 0, 0.0);
11582 ssSetOffsetTime(childS, 0, 0.0);
11583 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
11584
11585 /* set compiled values of dynamic vector attributes */
11586 ssSetNumNonsampledZCs(childS, 0);
11587
11588 /* Update connectivity flags for each port */
11589 _ssSetInputPortConnected(childS, 0, 1);
11590 _ssSetInputPortConnected(childS, 1, 1);
11591 _ssSetInputPortConnected(childS, 2, 1);
11592 _ssSetOutputPortConnected(childS, 0, 1);
11593 _ssSetOutputPortBeingMerged(childS, 0, 0);
11594
11595 /* Update the BufferDstPort flags for each input port */
11596 _ssSetInputPortBufferDstPort(childS, 0, -1);
11597 _ssSetInputPortBufferDstPort(childS, 1, -1);
11598 _ssSetInputPortBufferDstPort(childS, 2, -1);
11599 }
11600
11601 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S111>/Generated S-Function (Gain_sf) */
11602 {
11603 SimStruct *childS = ssGetSFunction(rts, 43);
11604
11605 /* timing info */
11606 time_T *sfcnPeriod;
11607 time_T *sfcnOffset;
11608 int_T *sfcnTsMap;
11609 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
11610 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
11611 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
11612 ss_VALIDATE_MEMORY(rts,sfcnOffset);
11613 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
11614 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
11615 (void) memset((void*)sfcnPeriod, 0,
11616 sizeof(time_T)*1);
11617 (void) memset((void*)sfcnOffset, 0,
11618 sizeof(time_T)*1);
11619 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
11620 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
11621 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
11622
11623 /* Set up the mdlInfo pointer */
11624# ifdef USE_RTMODEL
11625
11626 {
11627 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
11628 struct _ssBlkInfo2));
11629 ss_VALIDATE_MEMORY(rts,blkInfo2);
11630 ssSetBlkInfo2Ptr(childS, blkInfo2);
11631 }
11632
11633 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
11634
11635# else
11636
11637 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
11638
11639# endif /* USE_RTMODEL */
11640
11641 /* Allocate memory of model methods 2 */
11642 {
11643 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
11644 malloc(sizeof(struct _ssSFcnModelMethods2));
11645 ss_VALIDATE_MEMORY(rts,methods2);
11646 ssSetModelMethods2(childS, methods2);
11647 }
11648
11649 /* Allocate memory of model methods 3 */
11650 {
11651 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
11652 malloc(sizeof(struct _ssSFcnModelMethods3));
11653 ss_VALIDATE_MEMORY(rts,methods3);
11654 ssSetModelMethods3(childS, methods3);
11655 }
11656
11657 /* Allocate memory for states auxilliary information */
11658 {
11659 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
11660 (sizeof(struct _ssStatesInfo2));
11661 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
11662 malloc(sizeof(ssPeriodicStatesInfo));
11663 ss_VALIDATE_MEMORY(rts,statesInfo2);
11664 ssSetStatesInfo2(childS, statesInfo2);
11665 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
11666 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
11667 }
11668
11669 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
11670 RegNumInputPorts);
11671 ssSetRegNumInputPortsFcnArg(childS,childS);
11672
11673 /* inputs */
11674 {
11675 struct _ssPortInputs *inputPortInfo =
11676 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
11677 ss_VALIDATE_MEMORY(rts,inputPortInfo);
11678 _ssSetNumInputPorts(childS, 2);
11679 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
11680
11681 /* port 0 */
11682 {
11683 real32_T const **sfcnUPtrs = (real32_T const **)
11684 malloc(1 * sizeof(real32_T *));
11685 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11686 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
11687 ssGetLocalBlockIO(rts))->GeneratedSFunction1_g;
11688 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
11689 _ssSetInputPortNumDimensions(childS, 0, 1);
11690 ssSetInputPortWidth(childS, 0, 1);
11691 }
11692
11693 /* port 1 */
11694 {
11695 real32_T const **sfcnUPtrs = (real32_T const **)
11696 malloc(1 * sizeof(real32_T *));
11697 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11698 sfcnUPtrs[0] = (real32_T const *)
11699 &AFCS_MODEL1_ConstP.Constant13_Value_n;
11700 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
11701 _ssSetInputPortNumDimensions(childS, 1, 1);
11702 ssSetInputPortWidth(childS, 1, 1);
11703 }
11704 }
11705
11706 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
11707 RegNumOutputPorts);
11708 ssSetRegNumOutputPortsFcnArg(childS,childS);
11709
11710 /* outputs */
11711 {
11712 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
11713 calloc(1, sizeof(struct _ssPortOutputs));
11714 ss_VALIDATE_MEMORY(rts,outputPortInfo);
11715 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
11716 _ssSetNumOutputPorts(childS, 1);
11717
11718 /* port 0 */
11719 {
11720 _ssSetOutputPortNumDimensions(childS, 0, 1);
11721 ssSetOutputPortWidth(childS, 0, 1);
11722 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
11723 ssGetLocalBlockIO(rts))->GeneratedSFunction_nx));
11724 }
11725 }
11726
11727 /* path info */
11728 _ssSetModelName(childS, "Gain_sf");
11729 _ssSetPath(childS,
11730 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/gain/Generated S-Function");
11731 if (ssGetRTModel(rts) == (NULL)) {
11732 _ssSetParentSS(childS, rts);
11733 _ssSetRootSS(childS, ssGetRootSS(rts));
11734 } else {
11735 ssSetRTModel(childS,ssGetRTModel(rts));
11736 _ssSetParentSS(childS, (NULL));
11737 _ssSetRootSS(childS, childS);
11738 }
11739
11740 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
11741 (childS)->regDataType.arg1 = ((void *)(childS));
11742 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
11743 FcnSetErrorStatus);
11744 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
11745 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
11746 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
11747 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
11748
11749 /* registration */
11750#if defined(MATLAB_MEX_FILE)
11751
11752 {
11753 int_T i;
11754 mxArray *plhs[1];
11755 mxArray *prhs[4];
11756 double *pr;
11757 volatile int_T *intS = (int_T *)&childS;
11758 int_T addrlen = sizeof(SimStruct *);
11759 int_T m = addrlen/sizeof(int_T) + 1;
11760 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
11761 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
11762 pr = mxGetPr(prhs[1]);
11763 for (i = 0; i < m - 1; i++) {
11764 pr[i] = (double)intS[i];
11765 }
11766
11767 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
11768 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
11769 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
11770
11771 /* Reset port dimensions info functions because the S-function
11772 * and accelerator mex-files explicitly set their dimensions,
11773 * i.e., they are not dynamically sized. For this case, the
11774 * mex-file is responsible for the dimensions info memory
11775 * and Simulink should not free it. This is achieved by
11776 * setting the following two methods to NULL.
11777 */
11778 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
11779 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
11780
11781 /*
11782 * Setup function pointers and call mdlInitializeSizes via
11783 * simulink.c
11784 */
11785 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
11786 mxDestroyArray(plhs[0]);
11787 mxDestroyArray(prhs[0]);
11788 mxDestroyArray(prhs[1]);
11789 mxDestroyArray(prhs[2]);
11790 mxDestroyArray(prhs[3]);
11791 }
11792
11793#else
11794
11795 {
11796 Gain_sf(childS);
11797 sfcnInitializeSizes(childS);
11798 }
11799
11800#endif
11801
11802 sfcnInitializeSampleTimes(childS);
11803
11804 /* adjust sample time */
11805 ssSetSampleTime(childS, 0, 0.0);
11806 ssSetOffsetTime(childS, 0, 0.0);
11807 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
11808
11809 /* set compiled values of dynamic vector attributes */
11810 ssSetNumNonsampledZCs(childS, 0);
11811
11812 /* Update connectivity flags for each port */
11813 _ssSetInputPortConnected(childS, 0, 1);
11814 _ssSetInputPortConnected(childS, 1, 1);
11815 _ssSetOutputPortConnected(childS, 0, 1);
11816 _ssSetOutputPortBeingMerged(childS, 0, 0);
11817
11818 /* Update the BufferDstPort flags for each input port */
11819 _ssSetInputPortBufferDstPort(childS, 0, -1);
11820 _ssSetInputPortBufferDstPort(childS, 1, -1);
11821 }
11822
11823 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S112>/Generated S-Function (Gain_sf) */
11824 {
11825 SimStruct *childS = ssGetSFunction(rts, 44);
11826
11827 /* timing info */
11828 time_T *sfcnPeriod;
11829 time_T *sfcnOffset;
11830 int_T *sfcnTsMap;
11831 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
11832 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
11833 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
11834 ss_VALIDATE_MEMORY(rts,sfcnOffset);
11835 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
11836 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
11837 (void) memset((void*)sfcnPeriod, 0,
11838 sizeof(time_T)*1);
11839 (void) memset((void*)sfcnOffset, 0,
11840 sizeof(time_T)*1);
11841 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
11842 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
11843 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
11844
11845 /* Set up the mdlInfo pointer */
11846# ifdef USE_RTMODEL
11847
11848 {
11849 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
11850 struct _ssBlkInfo2));
11851 ss_VALIDATE_MEMORY(rts,blkInfo2);
11852 ssSetBlkInfo2Ptr(childS, blkInfo2);
11853 }
11854
11855 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
11856
11857# else
11858
11859 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
11860
11861# endif /* USE_RTMODEL */
11862
11863 /* Allocate memory of model methods 2 */
11864 {
11865 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
11866 malloc(sizeof(struct _ssSFcnModelMethods2));
11867 ss_VALIDATE_MEMORY(rts,methods2);
11868 ssSetModelMethods2(childS, methods2);
11869 }
11870
11871 /* Allocate memory of model methods 3 */
11872 {
11873 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
11874 malloc(sizeof(struct _ssSFcnModelMethods3));
11875 ss_VALIDATE_MEMORY(rts,methods3);
11876 ssSetModelMethods3(childS, methods3);
11877 }
11878
11879 /* Allocate memory for states auxilliary information */
11880 {
11881 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
11882 (sizeof(struct _ssStatesInfo2));
11883 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
11884 malloc(sizeof(ssPeriodicStatesInfo));
11885 ss_VALIDATE_MEMORY(rts,statesInfo2);
11886 ssSetStatesInfo2(childS, statesInfo2);
11887 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
11888 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
11889 }
11890
11891 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
11892 RegNumInputPorts);
11893 ssSetRegNumInputPortsFcnArg(childS,childS);
11894
11895 /* inputs */
11896 {
11897 struct _ssPortInputs *inputPortInfo =
11898 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
11899 ss_VALIDATE_MEMORY(rts,inputPortInfo);
11900 _ssSetNumInputPorts(childS, 2);
11901 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
11902
11903 /* port 0 */
11904 {
11905 real32_T const **sfcnUPtrs = (real32_T const **)
11906 malloc(1 * sizeof(real32_T *));
11907 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11908 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
11909 ssGetLocalBlockIO(rts))->GeneratedSFunction_nx;
11910 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
11911 _ssSetInputPortNumDimensions(childS, 0, 1);
11912 ssSetInputPortWidth(childS, 0, 1);
11913 }
11914
11915 /* port 1 */
11916 {
11917 real32_T const **sfcnUPtrs = (real32_T const **)
11918 malloc(1 * sizeof(real32_T *));
11919 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
11920 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
11921 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
11922 _ssSetInputPortNumDimensions(childS, 1, 1);
11923 ssSetInputPortWidth(childS, 1, 1);
11924 }
11925 }
11926
11927 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
11928 RegNumOutputPorts);
11929 ssSetRegNumOutputPortsFcnArg(childS,childS);
11930
11931 /* outputs */
11932 {
11933 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
11934 calloc(1, sizeof(struct _ssPortOutputs));
11935 ss_VALIDATE_MEMORY(rts,outputPortInfo);
11936 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
11937 _ssSetNumOutputPorts(childS, 1);
11938
11939 /* port 0 */
11940 {
11941 _ssSetOutputPortNumDimensions(childS, 0, 1);
11942 ssSetOutputPortWidth(childS, 0, 1);
11943 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
11944 ssGetLocalBlockIO(rts))->GeneratedSFunction_d));
11945 }
11946 }
11947
11948 /* path info */
11949 _ssSetModelName(childS, "Gain_sf");
11950 _ssSetPath(childS,
11951 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/gain4/Generated S-Function");
11952 if (ssGetRTModel(rts) == (NULL)) {
11953 _ssSetParentSS(childS, rts);
11954 _ssSetRootSS(childS, ssGetRootSS(rts));
11955 } else {
11956 ssSetRTModel(childS,ssGetRTModel(rts));
11957 _ssSetParentSS(childS, (NULL));
11958 _ssSetRootSS(childS, childS);
11959 }
11960
11961 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
11962 (childS)->regDataType.arg1 = ((void *)(childS));
11963 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
11964 FcnSetErrorStatus);
11965 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
11966 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
11967 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
11968 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
11969
11970 /* registration */
11971#if defined(MATLAB_MEX_FILE)
11972
11973 {
11974 int_T i;
11975 mxArray *plhs[1];
11976 mxArray *prhs[4];
11977 double *pr;
11978 volatile int_T *intS = (int_T *)&childS;
11979 int_T addrlen = sizeof(SimStruct *);
11980 int_T m = addrlen/sizeof(int_T) + 1;
11981 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
11982 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
11983 pr = mxGetPr(prhs[1]);
11984 for (i = 0; i < m - 1; i++) {
11985 pr[i] = (double)intS[i];
11986 }
11987
11988 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
11989 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
11990 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
11991
11992 /* Reset port dimensions info functions because the S-function
11993 * and accelerator mex-files explicitly set their dimensions,
11994 * i.e., they are not dynamically sized. For this case, the
11995 * mex-file is responsible for the dimensions info memory
11996 * and Simulink should not free it. This is achieved by
11997 * setting the following two methods to NULL.
11998 */
11999 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
12000 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
12001
12002 /*
12003 * Setup function pointers and call mdlInitializeSizes via
12004 * simulink.c
12005 */
12006 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
12007 mxDestroyArray(plhs[0]);
12008 mxDestroyArray(prhs[0]);
12009 mxDestroyArray(prhs[1]);
12010 mxDestroyArray(prhs[2]);
12011 mxDestroyArray(prhs[3]);
12012 }
12013
12014#else
12015
12016 {
12017 Gain_sf(childS);
12018 sfcnInitializeSizes(childS);
12019 }
12020
12021#endif
12022
12023 sfcnInitializeSampleTimes(childS);
12024
12025 /* adjust sample time */
12026 ssSetSampleTime(childS, 0, 0.0);
12027 ssSetOffsetTime(childS, 0, 0.0);
12028 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
12029
12030 /* set compiled values of dynamic vector attributes */
12031 ssSetNumNonsampledZCs(childS, 0);
12032
12033 /* Update connectivity flags for each port */
12034 _ssSetInputPortConnected(childS, 0, 1);
12035 _ssSetInputPortConnected(childS, 1, 1);
12036 _ssSetOutputPortConnected(childS, 0, 1);
12037 _ssSetOutputPortBeingMerged(childS, 0, 0);
12038
12039 /* Update the BufferDstPort flags for each input port */
12040 _ssSetInputPortBufferDstPort(childS, 0, -1);
12041 _ssSetInputPortBufferDstPort(childS, 1, -1);
12042 }
12043
12044 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S107>/Generated S-Function3 (IntegratorLimited_sf) */
12045 {
12046 SimStruct *childS = ssGetSFunction(rts, 45);
12047
12048 /* timing info */
12049 time_T *sfcnPeriod;
12050 time_T *sfcnOffset;
12051 int_T *sfcnTsMap;
12052 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
12053 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
12054 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
12055 ss_VALIDATE_MEMORY(rts,sfcnOffset);
12056 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
12057 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
12058 (void) memset((void*)sfcnPeriod, 0,
12059 sizeof(time_T)*1);
12060 (void) memset((void*)sfcnOffset, 0,
12061 sizeof(time_T)*1);
12062 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
12063 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
12064 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
12065
12066 /* Set up the mdlInfo pointer */
12067# ifdef USE_RTMODEL
12068
12069 {
12070 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
12071 struct _ssBlkInfo2));
12072 ss_VALIDATE_MEMORY(rts,blkInfo2);
12073 ssSetBlkInfo2Ptr(childS, blkInfo2);
12074 }
12075
12076 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
12077
12078# else
12079
12080 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
12081
12082# endif /* USE_RTMODEL */
12083
12084 /* Allocate memory of model methods 2 */
12085 {
12086 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
12087 malloc(sizeof(struct _ssSFcnModelMethods2));
12088 ss_VALIDATE_MEMORY(rts,methods2);
12089 ssSetModelMethods2(childS, methods2);
12090 }
12091
12092 /* Allocate memory of model methods 3 */
12093 {
12094 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
12095 malloc(sizeof(struct _ssSFcnModelMethods3));
12096 ss_VALIDATE_MEMORY(rts,methods3);
12097 ssSetModelMethods3(childS, methods3);
12098 }
12099
12100 /* Allocate memory for states auxilliary information */
12101 {
12102 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
12103 (sizeof(struct _ssStatesInfo2));
12104 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
12105 malloc(sizeof(ssPeriodicStatesInfo));
12106 ss_VALIDATE_MEMORY(rts,statesInfo2);
12107 ssSetStatesInfo2(childS, statesInfo2);
12108 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
12109 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
12110 }
12111
12112 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
12113 RegNumInputPorts);
12114 ssSetRegNumInputPortsFcnArg(childS,childS);
12115
12116 /* inputs */
12117 {
12118 struct _ssPortInputs *inputPortInfo =
12119 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
12120 ss_VALIDATE_MEMORY(rts,inputPortInfo);
12121 _ssSetNumInputPorts(childS, 7);
12122 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
12123
12124 /* port 0 */
12125 {
12126 real32_T const **sfcnUPtrs = (real32_T const **)
12127 malloc(1 * sizeof(real32_T *));
12128 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12129 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
12130 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
12131 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
12132 _ssSetInputPortNumDimensions(childS, 0, 1);
12133 ssSetInputPortWidth(childS, 0, 1);
12134 }
12135
12136 /* port 1 */
12137 {
12138 int8_T const **sfcnUPtrs = (int8_T const **)
12139 malloc(1 * sizeof(int8_T *));
12140 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12141 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
12142 ssGetLocalBlockIO(rts))->DataTypeConversion4_k;
12143 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
12144 _ssSetInputPortNumDimensions(childS, 1, 1);
12145 ssSetInputPortWidth(childS, 1, 1);
12146 }
12147
12148 /* port 2 */
12149 {
12150 real32_T const **sfcnUPtrs = (real32_T const **)
12151 malloc(1 * sizeof(real32_T *));
12152 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12153 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
12154 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
12155 _ssSetInputPortNumDimensions(childS, 2, 1);
12156 ssSetInputPortWidth(childS, 2, 1);
12157 }
12158
12159 /* port 3 */
12160 {
12161 real32_T const **sfcnUPtrs = (real32_T const **)
12162 malloc(1 * sizeof(real32_T *));
12163 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12164 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
12165 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
12166 _ssSetInputPortNumDimensions(childS, 3, 1);
12167 ssSetInputPortWidth(childS, 3, 1);
12168 }
12169
12170 /* port 4 */
12171 {
12172 real32_T const **sfcnUPtrs = (real32_T const **)
12173 malloc(1 * sizeof(real32_T *));
12174 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12175 sfcnUPtrs[0] = (real32_T const *)
12176 &AFCS_MODEL1_ConstP.Constant19_Value;
12177 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
12178 _ssSetInputPortNumDimensions(childS, 4, 1);
12179 ssSetInputPortWidth(childS, 4, 1);
12180 }
12181
12182 /* port 5 */
12183 {
12184 real32_T const **sfcnUPtrs = (real32_T const **)
12185 malloc(1 * sizeof(real32_T *));
12186 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12187 sfcnUPtrs[0] = (real32_T const *)
12188 &AFCS_MODEL1_ConstP.Constant76_Value;
12189 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
12190 _ssSetInputPortNumDimensions(childS, 5, 1);
12191 ssSetInputPortWidth(childS, 5, 1);
12192 }
12193
12194 /* port 6 */
12195 {
12196 real32_T const **sfcnUPtrs = (real32_T const **)
12197 malloc(1 * sizeof(real32_T *));
12198 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12199 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
12200 ssGetLocalBlockIO(rts))->GeneratedSFunction_d;
12201 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
12202 _ssSetInputPortNumDimensions(childS, 6, 1);
12203 ssSetInputPortWidth(childS, 6, 1);
12204 }
12205 }
12206
12207 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
12208 RegNumOutputPorts);
12209 ssSetRegNumOutputPortsFcnArg(childS,childS);
12210
12211 /* outputs */
12212 {
12213 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
12214 calloc(1, sizeof(struct _ssPortOutputs));
12215 ss_VALIDATE_MEMORY(rts,outputPortInfo);
12216 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
12217 _ssSetNumOutputPorts(childS, 1);
12218
12219 /* port 0 */
12220 {
12221 _ssSetOutputPortNumDimensions(childS, 0, 1);
12222 ssSetOutputPortWidth(childS, 0, 1);
12223 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
12224 ssGetLocalBlockIO(rts))->Saturation8));
12225 }
12226 }
12227
12228 /* path info */
12229 _ssSetModelName(childS, "IntegratorLimited_sf");
12230 _ssSetPath(childS,
12231 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/Integrator Limited1/Generated S-Function3");
12232 if (ssGetRTModel(rts) == (NULL)) {
12233 _ssSetParentSS(childS, rts);
12234 _ssSetRootSS(childS, ssGetRootSS(rts));
12235 } else {
12236 ssSetRTModel(childS,ssGetRTModel(rts));
12237 _ssSetParentSS(childS, (NULL));
12238 _ssSetRootSS(childS, childS);
12239 }
12240
12241 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
12242
12243 /* work vectors */
12244 {
12245 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
12246 (4 * sizeof(struct _ssDWorkRecord));
12247 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
12248 calloc(4, sizeof(struct _ssDWorkAuxRecord));
12249 ss_VALIDATE_MEMORY(rts,dWorkRecord);
12250 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
12251 ssSetSFcnDWork(childS, dWorkRecord);
12252 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
12253 _ssSetNumDWork(childS, 4);
12254
12255 /* DWORK0 */
12256 ssSetDWorkWidth(childS, 0, 1);
12257 ssSetDWorkDataType(childS, 0,SS_SINGLE);
12258 ssSetDWorkComplexSignal(childS, 0, 0);
12259 ssSetDWorkUsedAsDState(childS, 0, 1);
12260 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 182))[0]);
12261
12262 /* DWORK1 */
12263 ssSetDWorkWidth(childS, 1, 1);
12264 ssSetDWorkDataType(childS, 1,SS_SINGLE);
12265 ssSetDWorkComplexSignal(childS, 1, 0);
12266 ssSetDWorkUsedAsDState(childS, 1, 1);
12267 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 183))[0]);
12268
12269 /* DWORK2 */
12270 ssSetDWorkWidth(childS, 2, 1);
12271 ssSetDWorkDataType(childS, 2,SS_INT8);
12272 ssSetDWorkComplexSignal(childS, 2, 0);
12273 ssSetDWorkUsedAsDState(childS, 2, 1);
12274 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 409))[0]);
12275
12276 /* DWORK3 */
12277 ssSetDWorkWidth(childS, 3, 1);
12278 ssSetDWorkDataType(childS, 3,SS_INT8);
12279 ssSetDWorkComplexSignal(childS, 3, 0);
12280 ssSetDWorkUsedAsDState(childS, 3, 1);
12281 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 410))[0]);
12282 }
12283
12284 (childS)->regDataType.arg1 = ((void *)(childS));
12285 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
12286 FcnSetErrorStatus);
12287 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
12288 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
12289 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
12290 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
12291
12292 /* registration */
12293#if defined(MATLAB_MEX_FILE)
12294
12295 {
12296 int_T i;
12297 mxArray *plhs[1];
12298 mxArray *prhs[4];
12299 double *pr;
12300 volatile int_T *intS = (int_T *)&childS;
12301 int_T addrlen = sizeof(SimStruct *);
12302 int_T m = addrlen/sizeof(int_T) + 1;
12303 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
12304 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
12305 pr = mxGetPr(prhs[1]);
12306 for (i = 0; i < m - 1; i++) {
12307 pr[i] = (double)intS[i];
12308 }
12309
12310 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
12311 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
12312 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
12313
12314 /* Reset port dimensions info functions because the S-function
12315 * and accelerator mex-files explicitly set their dimensions,
12316 * i.e., they are not dynamically sized. For this case, the
12317 * mex-file is responsible for the dimensions info memory
12318 * and Simulink should not free it. This is achieved by
12319 * setting the following two methods to NULL.
12320 */
12321 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
12322 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
12323
12324 /*
12325 * Setup function pointers and call mdlInitializeSizes via
12326 * simulink.c
12327 */
12328 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
12329 mxDestroyArray(plhs[0]);
12330 mxDestroyArray(prhs[0]);
12331 mxDestroyArray(prhs[1]);
12332 mxDestroyArray(prhs[2]);
12333 mxDestroyArray(prhs[3]);
12334 }
12335
12336#else
12337
12338 {
12339 IntegratorLimited_sf(childS);
12340 sfcnInitializeSizes(childS);
12341 }
12342
12343#endif
12344
12345 sfcnInitializeSampleTimes(childS);
12346
12347 /* adjust sample time */
12348 ssSetSampleTime(childS, 0, 0.0);
12349 ssSetOffsetTime(childS, 0, 0.0);
12350 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
12351
12352 /* set compiled values of dynamic vector attributes */
12353 ssSetNumNonsampledZCs(childS, 0);
12354
12355 /* Update connectivity flags for each port */
12356 _ssSetInputPortConnected(childS, 0, 1);
12357 _ssSetInputPortConnected(childS, 1, 1);
12358 _ssSetInputPortConnected(childS, 2, 1);
12359 _ssSetInputPortConnected(childS, 3, 1);
12360 _ssSetInputPortConnected(childS, 4, 1);
12361 _ssSetInputPortConnected(childS, 5, 1);
12362 _ssSetInputPortConnected(childS, 6, 1);
12363 _ssSetOutputPortConnected(childS, 0, 1);
12364 _ssSetOutputPortBeingMerged(childS, 0, 0);
12365
12366 /* Update the BufferDstPort flags for each input port */
12367 _ssSetInputPortBufferDstPort(childS, 0, -1);
12368 _ssSetInputPortBufferDstPort(childS, 1, -1);
12369 _ssSetInputPortBufferDstPort(childS, 2, -1);
12370 _ssSetInputPortBufferDstPort(childS, 3, -1);
12371 _ssSetInputPortBufferDstPort(childS, 4, -1);
12372 _ssSetInputPortBufferDstPort(childS, 5, -1);
12373 _ssSetInputPortBufferDstPort(childS, 6, -1);
12374 }
12375
12376 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S108>/Generated S-Function2 (LeadLagFilter_sf) */
12377 {
12378 SimStruct *childS = ssGetSFunction(rts, 46);
12379
12380 /* timing info */
12381 time_T *sfcnPeriod;
12382 time_T *sfcnOffset;
12383 int_T *sfcnTsMap;
12384 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
12385 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
12386 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
12387 ss_VALIDATE_MEMORY(rts,sfcnOffset);
12388 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
12389 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
12390 (void) memset((void*)sfcnPeriod, 0,
12391 sizeof(time_T)*1);
12392 (void) memset((void*)sfcnOffset, 0,
12393 sizeof(time_T)*1);
12394 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
12395 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
12396 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
12397
12398 /* Set up the mdlInfo pointer */
12399# ifdef USE_RTMODEL
12400
12401 {
12402 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
12403 struct _ssBlkInfo2));
12404 ss_VALIDATE_MEMORY(rts,blkInfo2);
12405 ssSetBlkInfo2Ptr(childS, blkInfo2);
12406 }
12407
12408 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
12409
12410# else
12411
12412 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
12413
12414# endif /* USE_RTMODEL */
12415
12416 /* Allocate memory of model methods 2 */
12417 {
12418 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
12419 malloc(sizeof(struct _ssSFcnModelMethods2));
12420 ss_VALIDATE_MEMORY(rts,methods2);
12421 ssSetModelMethods2(childS, methods2);
12422 }
12423
12424 /* Allocate memory of model methods 3 */
12425 {
12426 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
12427 malloc(sizeof(struct _ssSFcnModelMethods3));
12428 ss_VALIDATE_MEMORY(rts,methods3);
12429 ssSetModelMethods3(childS, methods3);
12430 }
12431
12432 /* Allocate memory for states auxilliary information */
12433 {
12434 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
12435 (sizeof(struct _ssStatesInfo2));
12436 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
12437 malloc(sizeof(ssPeriodicStatesInfo));
12438 ss_VALIDATE_MEMORY(rts,statesInfo2);
12439 ssSetStatesInfo2(childS, statesInfo2);
12440 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
12441 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
12442 }
12443
12444 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
12445 RegNumInputPorts);
12446 ssSetRegNumInputPortsFcnArg(childS,childS);
12447
12448 /* inputs */
12449 {
12450 struct _ssPortInputs *inputPortInfo =
12451 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
12452 ss_VALIDATE_MEMORY(rts,inputPortInfo);
12453 _ssSetNumInputPorts(childS, 7);
12454 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
12455
12456 /* port 0 */
12457 {
12458 real32_T const **sfcnUPtrs = (real32_T const **)
12459 malloc(1 * sizeof(real32_T *));
12460 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12461 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
12462 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
12463 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
12464 _ssSetInputPortNumDimensions(childS, 0, 1);
12465 ssSetInputPortWidth(childS, 0, 1);
12466 }
12467
12468 /* port 1 */
12469 {
12470 int8_T const **sfcnUPtrs = (int8_T const **)
12471 malloc(1 * sizeof(int8_T *));
12472 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12473 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
12474 ssGetLocalBlockIO(rts))->DataTypeConversion4_k;
12475 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
12476 _ssSetInputPortNumDimensions(childS, 1, 1);
12477 ssSetInputPortWidth(childS, 1, 1);
12478 }
12479
12480 /* port 2 */
12481 {
12482 real32_T const **sfcnUPtrs = (real32_T const **)
12483 malloc(1 * sizeof(real32_T *));
12484 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12485 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
12486 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
12487 _ssSetInputPortNumDimensions(childS, 2, 1);
12488 ssSetInputPortWidth(childS, 2, 1);
12489 }
12490
12491 /* port 3 */
12492 {
12493 real32_T const **sfcnUPtrs = (real32_T const **)
12494 malloc(1 * sizeof(real32_T *));
12495 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12496 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;
12497 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
12498 _ssSetInputPortNumDimensions(childS, 3, 1);
12499 ssSetInputPortWidth(childS, 3, 1);
12500 }
12501
12502 /* port 4 */
12503 {
12504 real32_T const **sfcnUPtrs = (real32_T const **)
12505 malloc(1 * sizeof(real32_T *));
12506 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12507 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
12508 ssGetLocalBlockIO(rts))->Switch_aj;
12509 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
12510 _ssSetInputPortNumDimensions(childS, 4, 1);
12511 ssSetInputPortWidth(childS, 4, 1);
12512 }
12513
12514 /* port 5 */
12515 {
12516 real32_T const **sfcnUPtrs = (real32_T const **)
12517 malloc(1 * sizeof(real32_T *));
12518 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12519 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
12520 ssGetLocalBlockIO(rts))->Switch_aj;
12521 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
12522 _ssSetInputPortNumDimensions(childS, 5, 1);
12523 ssSetInputPortWidth(childS, 5, 1);
12524 }
12525
12526 /* port 6 */
12527 {
12528 real32_T const **sfcnUPtrs = (real32_T const **)
12529 malloc(1 * sizeof(real32_T *));
12530 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12531 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
12532 ssGetLocalBlockIO(rts))->Divide_ez;
12533 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
12534 _ssSetInputPortNumDimensions(childS, 6, 1);
12535 ssSetInputPortWidth(childS, 6, 1);
12536 }
12537 }
12538
12539 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
12540 RegNumOutputPorts);
12541 ssSetRegNumOutputPortsFcnArg(childS,childS);
12542
12543 /* outputs */
12544 {
12545 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
12546 calloc(1, sizeof(struct _ssPortOutputs));
12547 ss_VALIDATE_MEMORY(rts,outputPortInfo);
12548 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
12549 _ssSetNumOutputPorts(childS, 1);
12550
12551 /* port 0 */
12552 {
12553 _ssSetOutputPortNumDimensions(childS, 0, 1);
12554 ssSetOutputPortWidth(childS, 0, 1);
12555 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
12556 ssGetLocalBlockIO(rts))->GeneratedSFunction2_b));
12557 }
12558 }
12559
12560 /* path info */
12561 _ssSetModelName(childS, "LeadLagFilter_sf");
12562 _ssSetPath(childS,
12563 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/Lead lag/Generated S-Function2");
12564 if (ssGetRTModel(rts) == (NULL)) {
12565 _ssSetParentSS(childS, rts);
12566 _ssSetRootSS(childS, ssGetRootSS(rts));
12567 } else {
12568 ssSetRTModel(childS,ssGetRTModel(rts));
12569 _ssSetParentSS(childS, (NULL));
12570 _ssSetRootSS(childS, childS);
12571 }
12572
12573 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
12574
12575 /* work vectors */
12576 {
12577 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
12578 (4 * sizeof(struct _ssDWorkRecord));
12579 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
12580 calloc(4, sizeof(struct _ssDWorkAuxRecord));
12581 ss_VALIDATE_MEMORY(rts,dWorkRecord);
12582 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
12583 ssSetSFcnDWork(childS, dWorkRecord);
12584 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
12585 _ssSetNumDWork(childS, 4);
12586
12587 /* DWORK0 */
12588 ssSetDWorkWidth(childS, 0, 1);
12589 ssSetDWorkDataType(childS, 0,SS_SINGLE);
12590 ssSetDWorkComplexSignal(childS, 0, 0);
12591 ssSetDWorkUsedAsDState(childS, 0, 1);
12592 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 184))[0]);
12593
12594 /* DWORK1 */
12595 ssSetDWorkWidth(childS, 1, 1);
12596 ssSetDWorkDataType(childS, 1,SS_SINGLE);
12597 ssSetDWorkComplexSignal(childS, 1, 0);
12598 ssSetDWorkUsedAsDState(childS, 1, 1);
12599 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 185))[0]);
12600
12601 /* DWORK2 */
12602 ssSetDWorkWidth(childS, 2, 1);
12603 ssSetDWorkDataType(childS, 2,SS_INT8);
12604 ssSetDWorkComplexSignal(childS, 2, 0);
12605 ssSetDWorkUsedAsDState(childS, 2, 1);
12606 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 411))[0]);
12607
12608 /* DWORK3 */
12609 ssSetDWorkWidth(childS, 3, 1);
12610 ssSetDWorkDataType(childS, 3,SS_INT8);
12611 ssSetDWorkComplexSignal(childS, 3, 0);
12612 ssSetDWorkUsedAsDState(childS, 3, 1);
12613 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 412))[0]);
12614 }
12615
12616 (childS)->regDataType.arg1 = ((void *)(childS));
12617 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
12618 FcnSetErrorStatus);
12619 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
12620 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
12621 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
12622 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
12623
12624 /* registration */
12625#if defined(MATLAB_MEX_FILE)
12626
12627 {
12628 int_T i;
12629 mxArray *plhs[1];
12630 mxArray *prhs[4];
12631 double *pr;
12632 volatile int_T *intS = (int_T *)&childS;
12633 int_T addrlen = sizeof(SimStruct *);
12634 int_T m = addrlen/sizeof(int_T) + 1;
12635 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
12636 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
12637 pr = mxGetPr(prhs[1]);
12638 for (i = 0; i < m - 1; i++) {
12639 pr[i] = (double)intS[i];
12640 }
12641
12642 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
12643 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
12644 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
12645
12646 /* Reset port dimensions info functions because the S-function
12647 * and accelerator mex-files explicitly set their dimensions,
12648 * i.e., they are not dynamically sized. For this case, the
12649 * mex-file is responsible for the dimensions info memory
12650 * and Simulink should not free it. This is achieved by
12651 * setting the following two methods to NULL.
12652 */
12653 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
12654 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
12655
12656 /*
12657 * Setup function pointers and call mdlInitializeSizes via
12658 * simulink.c
12659 */
12660 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
12661 mxDestroyArray(plhs[0]);
12662 mxDestroyArray(prhs[0]);
12663 mxDestroyArray(prhs[1]);
12664 mxDestroyArray(prhs[2]);
12665 mxDestroyArray(prhs[3]);
12666 }
12667
12668#else
12669
12670 {
12671 LeadLagFilter_sf(childS);
12672 sfcnInitializeSizes(childS);
12673 }
12674
12675#endif
12676
12677 sfcnInitializeSampleTimes(childS);
12678
12679 /* adjust sample time */
12680 ssSetSampleTime(childS, 0, 0.0);
12681 ssSetOffsetTime(childS, 0, 0.0);
12682 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
12683
12684 /* set compiled values of dynamic vector attributes */
12685 ssSetNumNonsampledZCs(childS, 0);
12686
12687 /* Update connectivity flags for each port */
12688 _ssSetInputPortConnected(childS, 0, 1);
12689 _ssSetInputPortConnected(childS, 1, 1);
12690 _ssSetInputPortConnected(childS, 2, 1);
12691 _ssSetInputPortConnected(childS, 3, 1);
12692 _ssSetInputPortConnected(childS, 4, 1);
12693 _ssSetInputPortConnected(childS, 5, 1);
12694 _ssSetInputPortConnected(childS, 6, 1);
12695 _ssSetOutputPortConnected(childS, 0, 1);
12696 _ssSetOutputPortBeingMerged(childS, 0, 0);
12697
12698 /* Update the BufferDstPort flags for each input port */
12699 _ssSetInputPortBufferDstPort(childS, 0, -1);
12700 _ssSetInputPortBufferDstPort(childS, 1, -1);
12701 _ssSetInputPortBufferDstPort(childS, 2, -1);
12702 _ssSetInputPortBufferDstPort(childS, 3, -1);
12703 _ssSetInputPortBufferDstPort(childS, 4, -1);
12704 _ssSetInputPortBufferDstPort(childS, 5, -1);
12705 _ssSetInputPortBufferDstPort(childS, 6, -1);
12706 }
12707
12708 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S110>/Generated S-Function1 (SaturationLimiter_sf) */
12709 {
12710 SimStruct *childS = ssGetSFunction(rts, 47);
12711
12712 /* timing info */
12713 time_T *sfcnPeriod;
12714 time_T *sfcnOffset;
12715 int_T *sfcnTsMap;
12716 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
12717 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
12718 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
12719 ss_VALIDATE_MEMORY(rts,sfcnOffset);
12720 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
12721 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
12722 (void) memset((void*)sfcnPeriod, 0,
12723 sizeof(time_T)*1);
12724 (void) memset((void*)sfcnOffset, 0,
12725 sizeof(time_T)*1);
12726 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
12727 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
12728 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
12729
12730 /* Set up the mdlInfo pointer */
12731# ifdef USE_RTMODEL
12732
12733 {
12734 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
12735 struct _ssBlkInfo2));
12736 ss_VALIDATE_MEMORY(rts,blkInfo2);
12737 ssSetBlkInfo2Ptr(childS, blkInfo2);
12738 }
12739
12740 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
12741
12742# else
12743
12744 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
12745
12746# endif /* USE_RTMODEL */
12747
12748 /* Allocate memory of model methods 2 */
12749 {
12750 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
12751 malloc(sizeof(struct _ssSFcnModelMethods2));
12752 ss_VALIDATE_MEMORY(rts,methods2);
12753 ssSetModelMethods2(childS, methods2);
12754 }
12755
12756 /* Allocate memory of model methods 3 */
12757 {
12758 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
12759 malloc(sizeof(struct _ssSFcnModelMethods3));
12760 ss_VALIDATE_MEMORY(rts,methods3);
12761 ssSetModelMethods3(childS, methods3);
12762 }
12763
12764 /* Allocate memory for states auxilliary information */
12765 {
12766 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
12767 (sizeof(struct _ssStatesInfo2));
12768 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
12769 malloc(sizeof(ssPeriodicStatesInfo));
12770 ss_VALIDATE_MEMORY(rts,statesInfo2);
12771 ssSetStatesInfo2(childS, statesInfo2);
12772 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
12773 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
12774 }
12775
12776 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
12777 RegNumInputPorts);
12778 ssSetRegNumInputPortsFcnArg(childS,childS);
12779
12780 /* inputs */
12781 {
12782 struct _ssPortInputs *inputPortInfo =
12783 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
12784 ss_VALIDATE_MEMORY(rts,inputPortInfo);
12785 _ssSetNumInputPorts(childS, 3);
12786 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
12787
12788 /* port 0 */
12789 {
12790 real32_T const **sfcnUPtrs = (real32_T const **)
12791 malloc(1 * sizeof(real32_T *));
12792 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12793 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
12794 ssGetLocalBlockIO(rts))->GeneratedSFunction2_b;
12795 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
12796 _ssSetInputPortNumDimensions(childS, 0, 1);
12797 ssSetInputPortWidth(childS, 0, 1);
12798 }
12799
12800 /* port 1 */
12801 {
12802 real32_T const **sfcnUPtrs = (real32_T const **)
12803 malloc(1 * sizeof(real32_T *));
12804 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12805 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
12806 ssGetLocalBlockIO(rts))->Product1_m;
12807 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
12808 _ssSetInputPortNumDimensions(childS, 1, 1);
12809 ssSetInputPortWidth(childS, 1, 1);
12810 }
12811
12812 /* port 2 */
12813 {
12814 real32_T const **sfcnUPtrs = (real32_T const **)
12815 malloc(1 * sizeof(real32_T *));
12816 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
12817 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
12818 ssGetLocalBlockIO(rts))->Product_pp;
12819 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
12820 _ssSetInputPortNumDimensions(childS, 2, 1);
12821 ssSetInputPortWidth(childS, 2, 1);
12822 }
12823 }
12824
12825 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
12826 RegNumOutputPorts);
12827 ssSetRegNumOutputPortsFcnArg(childS,childS);
12828
12829 /* outputs */
12830 {
12831 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
12832 calloc(1, sizeof(struct _ssPortOutputs));
12833 ss_VALIDATE_MEMORY(rts,outputPortInfo);
12834 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
12835 _ssSetNumOutputPorts(childS, 1);
12836
12837 /* port 0 */
12838 {
12839 _ssSetOutputPortNumDimensions(childS, 0, 1);
12840 ssSetOutputPortWidth(childS, 0, 1);
12841 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
12842 ssGetLocalBlockIO(rts))->GeneratedSFunction1_l));
12843 }
12844 }
12845
12846 /* path info */
12847 _ssSetModelName(childS, "SaturationLimiter_sf");
12848 _ssSetPath(childS,
12849 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/Saturation Limiter2/Generated S-Function1");
12850 if (ssGetRTModel(rts) == (NULL)) {
12851 _ssSetParentSS(childS, rts);
12852 _ssSetRootSS(childS, ssGetRootSS(rts));
12853 } else {
12854 ssSetRTModel(childS,ssGetRTModel(rts));
12855 _ssSetParentSS(childS, (NULL));
12856 _ssSetRootSS(childS, childS);
12857 }
12858
12859 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
12860 (childS)->regDataType.arg1 = ((void *)(childS));
12861 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
12862 FcnSetErrorStatus);
12863 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
12864 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
12865 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
12866 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
12867
12868 /* registration */
12869#if defined(MATLAB_MEX_FILE)
12870
12871 {
12872 int_T i;
12873 mxArray *plhs[1];
12874 mxArray *prhs[4];
12875 double *pr;
12876 volatile int_T *intS = (int_T *)&childS;
12877 int_T addrlen = sizeof(SimStruct *);
12878 int_T m = addrlen/sizeof(int_T) + 1;
12879 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
12880 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
12881 pr = mxGetPr(prhs[1]);
12882 for (i = 0; i < m - 1; i++) {
12883 pr[i] = (double)intS[i];
12884 }
12885
12886 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
12887 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
12888 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
12889
12890 /* Reset port dimensions info functions because the S-function
12891 * and accelerator mex-files explicitly set their dimensions,
12892 * i.e., they are not dynamically sized. For this case, the
12893 * mex-file is responsible for the dimensions info memory
12894 * and Simulink should not free it. This is achieved by
12895 * setting the following two methods to NULL.
12896 */
12897 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
12898 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
12899
12900 /*
12901 * Setup function pointers and call mdlInitializeSizes via
12902 * simulink.c
12903 */
12904 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
12905 mxDestroyArray(plhs[0]);
12906 mxDestroyArray(prhs[0]);
12907 mxDestroyArray(prhs[1]);
12908 mxDestroyArray(prhs[2]);
12909 mxDestroyArray(prhs[3]);
12910 }
12911
12912#else
12913
12914 {
12915 SaturationLimiter_sf(childS);
12916 sfcnInitializeSizes(childS);
12917 }
12918
12919#endif
12920
12921 sfcnInitializeSampleTimes(childS);
12922
12923 /* adjust sample time */
12924 ssSetSampleTime(childS, 0, 0.0);
12925 ssSetOffsetTime(childS, 0, 0.0);
12926 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
12927
12928 /* set compiled values of dynamic vector attributes */
12929 ssSetNumNonsampledZCs(childS, 0);
12930
12931 /* Update connectivity flags for each port */
12932 _ssSetInputPortConnected(childS, 0, 1);
12933 _ssSetInputPortConnected(childS, 1, 1);
12934 _ssSetInputPortConnected(childS, 2, 1);
12935 _ssSetOutputPortConnected(childS, 0, 1);
12936 _ssSetOutputPortBeingMerged(childS, 0, 0);
12937
12938 /* Update the BufferDstPort flags for each input port */
12939 _ssSetInputPortBufferDstPort(childS, 0, -1);
12940 _ssSetInputPortBufferDstPort(childS, 1, -1);
12941 _ssSetInputPortBufferDstPort(childS, 2, -1);
12942 }
12943
12944 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S106>/Generated S-Function4 (LagFilter_sf) */
12945 {
12946 SimStruct *childS = ssGetSFunction(rts, 48);
12947
12948 /* timing info */
12949 time_T *sfcnPeriod;
12950 time_T *sfcnOffset;
12951 int_T *sfcnTsMap;
12952 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
12953 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
12954 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
12955 ss_VALIDATE_MEMORY(rts,sfcnOffset);
12956 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
12957 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
12958 (void) memset((void*)sfcnPeriod, 0,
12959 sizeof(time_T)*1);
12960 (void) memset((void*)sfcnOffset, 0,
12961 sizeof(time_T)*1);
12962 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
12963 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
12964 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
12965
12966 /* Set up the mdlInfo pointer */
12967# ifdef USE_RTMODEL
12968
12969 {
12970 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
12971 struct _ssBlkInfo2));
12972 ss_VALIDATE_MEMORY(rts,blkInfo2);
12973 ssSetBlkInfo2Ptr(childS, blkInfo2);
12974 }
12975
12976 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
12977
12978# else
12979
12980 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
12981
12982# endif /* USE_RTMODEL */
12983
12984 /* Allocate memory of model methods 2 */
12985 {
12986 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
12987 malloc(sizeof(struct _ssSFcnModelMethods2));
12988 ss_VALIDATE_MEMORY(rts,methods2);
12989 ssSetModelMethods2(childS, methods2);
12990 }
12991
12992 /* Allocate memory of model methods 3 */
12993 {
12994 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
12995 malloc(sizeof(struct _ssSFcnModelMethods3));
12996 ss_VALIDATE_MEMORY(rts,methods3);
12997 ssSetModelMethods3(childS, methods3);
12998 }
12999
13000 /* Allocate memory for states auxilliary information */
13001 {
13002 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
13003 (sizeof(struct _ssStatesInfo2));
13004 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
13005 malloc(sizeof(ssPeriodicStatesInfo));
13006 ss_VALIDATE_MEMORY(rts,statesInfo2);
13007 ssSetStatesInfo2(childS, statesInfo2);
13008 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
13009 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
13010 }
13011
13012 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
13013 RegNumInputPorts);
13014 ssSetRegNumInputPortsFcnArg(childS,childS);
13015
13016 /* inputs */
13017 {
13018 struct _ssPortInputs *inputPortInfo =
13019 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
13020 ss_VALIDATE_MEMORY(rts,inputPortInfo);
13021 _ssSetNumInputPorts(childS, 6);
13022 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
13023
13024 /* port 0 */
13025 {
13026 real32_T const **sfcnUPtrs = (real32_T const **)
13027 malloc(1 * sizeof(real32_T *));
13028 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13029 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13030 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
13031 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
13032 _ssSetInputPortNumDimensions(childS, 0, 1);
13033 ssSetInputPortWidth(childS, 0, 1);
13034 }
13035
13036 /* port 1 */
13037 {
13038 int8_T const **sfcnUPtrs = (int8_T const **)
13039 malloc(1 * sizeof(int8_T *));
13040 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13041 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
13042 ssGetLocalBlockIO(rts))->DataTypeConversion4_k;
13043 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
13044 _ssSetInputPortNumDimensions(childS, 1, 1);
13045 ssSetInputPortWidth(childS, 1, 1);
13046 }
13047
13048 /* port 2 */
13049 {
13050 real32_T const **sfcnUPtrs = (real32_T const **)
13051 malloc(1 * sizeof(real32_T *));
13052 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13053 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
13054 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
13055 _ssSetInputPortNumDimensions(childS, 2, 1);
13056 ssSetInputPortWidth(childS, 2, 1);
13057 }
13058
13059 /* port 3 */
13060 {
13061 real32_T const **sfcnUPtrs = (real32_T const **)
13062 malloc(1 * sizeof(real32_T *));
13063 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13064 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13065 ssGetLocalBlockIO(rts))->Switch_aj;
13066 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
13067 _ssSetInputPortNumDimensions(childS, 3, 1);
13068 ssSetInputPortWidth(childS, 3, 1);
13069 }
13070
13071 /* port 4 */
13072 {
13073 real32_T const **sfcnUPtrs = (real32_T const **)
13074 malloc(1 * sizeof(real32_T *));
13075 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13076 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13077 ssGetLocalBlockIO(rts))->Switch_aj;
13078 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
13079 _ssSetInputPortNumDimensions(childS, 4, 1);
13080 ssSetInputPortWidth(childS, 4, 1);
13081 }
13082
13083 /* port 5 */
13084 {
13085 real32_T const **sfcnUPtrs = (real32_T const **)
13086 malloc(1 * sizeof(real32_T *));
13087 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13088 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13089 ssGetLocalBlockIO(rts))->GeneratedSFunction1_l;
13090 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
13091 _ssSetInputPortNumDimensions(childS, 5, 1);
13092 ssSetInputPortWidth(childS, 5, 1);
13093 }
13094 }
13095
13096 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
13097 RegNumOutputPorts);
13098 ssSetRegNumOutputPortsFcnArg(childS,childS);
13099
13100 /* outputs */
13101 {
13102 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
13103 calloc(1, sizeof(struct _ssPortOutputs));
13104 ss_VALIDATE_MEMORY(rts,outputPortInfo);
13105 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
13106 _ssSetNumOutputPorts(childS, 1);
13107
13108 /* port 0 */
13109 {
13110 _ssSetOutputPortNumDimensions(childS, 0, 1);
13111 ssSetOutputPortWidth(childS, 0, 1);
13112 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
13113 ssGetLocalBlockIO(rts))->GeneratedSFunction4_n));
13114 }
13115 }
13116
13117 /* path info */
13118 _ssSetModelName(childS, "LagFilter_sf");
13119 _ssSetPath(childS,
13120 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/HdotLControl/ lag filter/Generated S-Function4");
13121 if (ssGetRTModel(rts) == (NULL)) {
13122 _ssSetParentSS(childS, rts);
13123 _ssSetRootSS(childS, ssGetRootSS(rts));
13124 } else {
13125 ssSetRTModel(childS,ssGetRTModel(rts));
13126 _ssSetParentSS(childS, (NULL));
13127 _ssSetRootSS(childS, childS);
13128 }
13129
13130 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
13131
13132 /* work vectors */
13133 {
13134 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
13135 (4 * sizeof(struct _ssDWorkRecord));
13136 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
13137 calloc(4, sizeof(struct _ssDWorkAuxRecord));
13138 ss_VALIDATE_MEMORY(rts,dWorkRecord);
13139 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
13140 ssSetSFcnDWork(childS, dWorkRecord);
13141 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
13142 _ssSetNumDWork(childS, 4);
13143
13144 /* DWORK0 */
13145 ssSetDWorkWidth(childS, 0, 1);
13146 ssSetDWorkDataType(childS, 0,SS_SINGLE);
13147 ssSetDWorkComplexSignal(childS, 0, 0);
13148 ssSetDWorkUsedAsDState(childS, 0, 1);
13149 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 186))[0]);
13150
13151 /* DWORK1 */
13152 ssSetDWorkWidth(childS, 1, 1);
13153 ssSetDWorkDataType(childS, 1,SS_SINGLE);
13154 ssSetDWorkComplexSignal(childS, 1, 0);
13155 ssSetDWorkUsedAsDState(childS, 1, 1);
13156 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 187))[0]);
13157
13158 /* DWORK2 */
13159 ssSetDWorkWidth(childS, 2, 1);
13160 ssSetDWorkDataType(childS, 2,SS_INT8);
13161 ssSetDWorkComplexSignal(childS, 2, 0);
13162 ssSetDWorkUsedAsDState(childS, 2, 1);
13163 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 413))[0]);
13164
13165 /* DWORK3 */
13166 ssSetDWorkWidth(childS, 3, 1);
13167 ssSetDWorkDataType(childS, 3,SS_INT8);
13168 ssSetDWorkComplexSignal(childS, 3, 0);
13169 ssSetDWorkUsedAsDState(childS, 3, 1);
13170 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 414))[0]);
13171 }
13172
13173 (childS)->regDataType.arg1 = ((void *)(childS));
13174 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
13175 FcnSetErrorStatus);
13176 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
13177 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
13178 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
13179 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
13180
13181 /* registration */
13182#if defined(MATLAB_MEX_FILE)
13183
13184 {
13185 int_T i;
13186 mxArray *plhs[1];
13187 mxArray *prhs[4];
13188 double *pr;
13189 volatile int_T *intS = (int_T *)&childS;
13190 int_T addrlen = sizeof(SimStruct *);
13191 int_T m = addrlen/sizeof(int_T) + 1;
13192 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
13193 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
13194 pr = mxGetPr(prhs[1]);
13195 for (i = 0; i < m - 1; i++) {
13196 pr[i] = (double)intS[i];
13197 }
13198
13199 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
13200 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
13201 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
13202
13203 /* Reset port dimensions info functions because the S-function
13204 * and accelerator mex-files explicitly set their dimensions,
13205 * i.e., they are not dynamically sized. For this case, the
13206 * mex-file is responsible for the dimensions info memory
13207 * and Simulink should not free it. This is achieved by
13208 * setting the following two methods to NULL.
13209 */
13210 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
13211 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
13212
13213 /*
13214 * Setup function pointers and call mdlInitializeSizes via
13215 * simulink.c
13216 */
13217 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
13218 mxDestroyArray(plhs[0]);
13219 mxDestroyArray(prhs[0]);
13220 mxDestroyArray(prhs[1]);
13221 mxDestroyArray(prhs[2]);
13222 mxDestroyArray(prhs[3]);
13223 }
13224
13225#else
13226
13227 {
13228 LagFilter_sf(childS);
13229 sfcnInitializeSizes(childS);
13230 }
13231
13232#endif
13233
13234 sfcnInitializeSampleTimes(childS);
13235
13236 /* adjust sample time */
13237 ssSetSampleTime(childS, 0, 0.0);
13238 ssSetOffsetTime(childS, 0, 0.0);
13239 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
13240
13241 /* set compiled values of dynamic vector attributes */
13242 ssSetNumNonsampledZCs(childS, 0);
13243
13244 /* Update connectivity flags for each port */
13245 _ssSetInputPortConnected(childS, 0, 1);
13246 _ssSetInputPortConnected(childS, 1, 1);
13247 _ssSetInputPortConnected(childS, 2, 1);
13248 _ssSetInputPortConnected(childS, 3, 1);
13249 _ssSetInputPortConnected(childS, 4, 1);
13250 _ssSetInputPortConnected(childS, 5, 1);
13251 _ssSetOutputPortConnected(childS, 0, 1);
13252 _ssSetOutputPortBeingMerged(childS, 0, 0);
13253
13254 /* Update the BufferDstPort flags for each input port */
13255 _ssSetInputPortBufferDstPort(childS, 0, -1);
13256 _ssSetInputPortBufferDstPort(childS, 1, -1);
13257 _ssSetInputPortBufferDstPort(childS, 2, -1);
13258 _ssSetInputPortBufferDstPort(childS, 3, -1);
13259 _ssSetInputPortBufferDstPort(childS, 4, -1);
13260 _ssSetInputPortBufferDstPort(childS, 5, -1);
13261 }
13262
13263 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S81>/Generated S-Function5 (Fader_sf) */
13264 {
13265 SimStruct *childS = ssGetSFunction(rts, 49);
13266
13267 /* timing info */
13268 time_T *sfcnPeriod;
13269 time_T *sfcnOffset;
13270 int_T *sfcnTsMap;
13271 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
13272 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
13273 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
13274 ss_VALIDATE_MEMORY(rts,sfcnOffset);
13275 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
13276 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
13277 (void) memset((void*)sfcnPeriod, 0,
13278 sizeof(time_T)*1);
13279 (void) memset((void*)sfcnOffset, 0,
13280 sizeof(time_T)*1);
13281 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
13282 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
13283 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
13284
13285 /* Set up the mdlInfo pointer */
13286# ifdef USE_RTMODEL
13287
13288 {
13289 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
13290 struct _ssBlkInfo2));
13291 ss_VALIDATE_MEMORY(rts,blkInfo2);
13292 ssSetBlkInfo2Ptr(childS, blkInfo2);
13293 }
13294
13295 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
13296
13297# else
13298
13299 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
13300
13301# endif /* USE_RTMODEL */
13302
13303 /* Allocate memory of model methods 2 */
13304 {
13305 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
13306 malloc(sizeof(struct _ssSFcnModelMethods2));
13307 ss_VALIDATE_MEMORY(rts,methods2);
13308 ssSetModelMethods2(childS, methods2);
13309 }
13310
13311 /* Allocate memory of model methods 3 */
13312 {
13313 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
13314 malloc(sizeof(struct _ssSFcnModelMethods3));
13315 ss_VALIDATE_MEMORY(rts,methods3);
13316 ssSetModelMethods3(childS, methods3);
13317 }
13318
13319 /* Allocate memory for states auxilliary information */
13320 {
13321 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
13322 (sizeof(struct _ssStatesInfo2));
13323 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
13324 malloc(sizeof(ssPeriodicStatesInfo));
13325 ss_VALIDATE_MEMORY(rts,statesInfo2);
13326 ssSetStatesInfo2(childS, statesInfo2);
13327 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
13328 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
13329 }
13330
13331 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
13332 RegNumInputPorts);
13333 ssSetRegNumInputPortsFcnArg(childS,childS);
13334
13335 /* inputs */
13336 {
13337 struct _ssPortInputs *inputPortInfo =
13338 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
13339 ss_VALIDATE_MEMORY(rts,inputPortInfo);
13340 _ssSetNumInputPorts(childS, 6);
13341 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
13342
13343 /* port 0 */
13344 {
13345 real32_T const **sfcnUPtrs = (real32_T const **)
13346 malloc(1 * sizeof(real32_T *));
13347 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13348 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13349 ssGetLocalBlockIO(rts))->MultiportSwitch2;
13350 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
13351 _ssSetInputPortNumDimensions(childS, 0, 1);
13352 ssSetInputPortWidth(childS, 0, 1);
13353 }
13354
13355 /* port 1 */
13356 {
13357 real32_T const **sfcnUPtrs = (real32_T const **)
13358 malloc(1 * sizeof(real32_T *));
13359 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13360 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13361 ssGetLocalBlockIO(rts))->MultiportSwitch2;
13362 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
13363 _ssSetInputPortNumDimensions(childS, 1, 1);
13364 ssSetInputPortWidth(childS, 1, 1);
13365 }
13366
13367 /* port 2 */
13368 {
13369 int8_T const **sfcnUPtrs = (int8_T const **)
13370 malloc(1 * sizeof(int8_T *));
13371 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13372 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
13373 ssGetLocalBlockIO(rts))->Switch9;
13374 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
13375 _ssSetInputPortNumDimensions(childS, 2, 1);
13376 ssSetInputPortWidth(childS, 2, 1);
13377 }
13378
13379 /* port 3 */
13380 {
13381 int8_T const **sfcnUPtrs = (int8_T const **)
13382 malloc(1 * sizeof(int8_T *));
13383 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13384 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
13385 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
13386 _ssSetInputPortNumDimensions(childS, 3, 1);
13387 ssSetInputPortWidth(childS, 3, 1);
13388 }
13389
13390 /* port 4 */
13391 {
13392 real32_T const **sfcnUPtrs = (real32_T const **)
13393 malloc(1 * sizeof(real32_T *));
13394 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13395 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
13396 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
13397 _ssSetInputPortNumDimensions(childS, 4, 1);
13398 ssSetInputPortWidth(childS, 4, 1);
13399 }
13400
13401 /* port 5 */
13402 {
13403 real32_T const **sfcnUPtrs = (real32_T const **)
13404 malloc(1 * sizeof(real32_T *));
13405 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13406 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13407 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
13408 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
13409 _ssSetInputPortNumDimensions(childS, 5, 1);
13410 ssSetInputPortWidth(childS, 5, 1);
13411 }
13412 }
13413
13414 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
13415 RegNumOutputPorts);
13416 ssSetRegNumOutputPortsFcnArg(childS,childS);
13417
13418 /* outputs */
13419 {
13420 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
13421 calloc(1, sizeof(struct _ssPortOutputs));
13422 ss_VALIDATE_MEMORY(rts,outputPortInfo);
13423 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
13424 _ssSetNumOutputPorts(childS, 1);
13425
13426 /* port 0 */
13427 {
13428 _ssSetOutputPortNumDimensions(childS, 0, 1);
13429 ssSetOutputPortWidth(childS, 0, 1);
13430 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
13431 ssGetLocalBlockIO(rts))->appc));
13432 }
13433 }
13434
13435 /* path info */
13436 _ssSetModelName(childS, "Fader_sf");
13437 _ssSetPath(childS,
13438 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/appcLcontrol/Fader/Generated S-Function5");
13439 if (ssGetRTModel(rts) == (NULL)) {
13440 _ssSetParentSS(childS, rts);
13441 _ssSetRootSS(childS, ssGetRootSS(rts));
13442 } else {
13443 ssSetRTModel(childS,ssGetRTModel(rts));
13444 _ssSetParentSS(childS, (NULL));
13445 _ssSetRootSS(childS, childS);
13446 }
13447
13448 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
13449
13450 /* work vectors */
13451 {
13452 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
13453 (7 * sizeof(struct _ssDWorkRecord));
13454 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
13455 calloc(7, sizeof(struct _ssDWorkAuxRecord));
13456 ss_VALIDATE_MEMORY(rts,dWorkRecord);
13457 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
13458 ssSetSFcnDWork(childS, dWorkRecord);
13459 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
13460 _ssSetNumDWork(childS, 7);
13461
13462 /* DWORK0 */
13463 ssSetDWorkWidth(childS, 0, 1);
13464 ssSetDWorkDataType(childS, 0,SS_SINGLE);
13465 ssSetDWorkComplexSignal(childS, 0, 0);
13466 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 289))[0]);
13467
13468 /* DWORK1 */
13469 ssSetDWorkWidth(childS, 1, 1);
13470 ssSetDWorkDataType(childS, 1,SS_SINGLE);
13471 ssSetDWorkComplexSignal(childS, 1, 0);
13472 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 290))[0]);
13473
13474 /* DWORK2 */
13475 ssSetDWorkWidth(childS, 2, 1);
13476 ssSetDWorkDataType(childS, 2,SS_SINGLE);
13477 ssSetDWorkComplexSignal(childS, 2, 0);
13478 _ssSetDWork(childS, 2, &((real32_T*) ssGetDWork(rts, 291))[0]);
13479
13480 /* DWORK3 */
13481 ssSetDWorkWidth(childS, 3, 1);
13482 ssSetDWorkDataType(childS, 3,SS_INT32);
13483 ssSetDWorkComplexSignal(childS, 3, 0);
13484 _ssSetDWork(childS, 3, &((int32_T*) ssGetDWork(rts, 332))[0]);
13485
13486 /* DWORK4 */
13487 ssSetDWorkWidth(childS, 4, 1);
13488 ssSetDWorkDataType(childS, 4,SS_INT32);
13489 ssSetDWorkComplexSignal(childS, 4, 0);
13490 _ssSetDWork(childS, 4, &((int32_T*) ssGetDWork(rts, 333))[0]);
13491
13492 /* DWORK5 */
13493 ssSetDWorkWidth(childS, 5, 1);
13494 ssSetDWorkDataType(childS, 5,SS_INT8);
13495 ssSetDWorkComplexSignal(childS, 5, 0);
13496 _ssSetDWork(childS, 5, &((int8_T*) ssGetDWork(rts, 517))[0]);
13497
13498 /* DWORK6 */
13499 ssSetDWorkWidth(childS, 6, 1);
13500 ssSetDWorkDataType(childS, 6,SS_INT8);
13501 ssSetDWorkComplexSignal(childS, 6, 0);
13502 _ssSetDWork(childS, 6, &((int8_T*) ssGetDWork(rts, 518))[0]);
13503 }
13504
13505 (childS)->regDataType.arg1 = ((void *)(childS));
13506 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
13507 FcnSetErrorStatus);
13508 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
13509 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
13510 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
13511 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
13512
13513 /* registration */
13514#if defined(MATLAB_MEX_FILE)
13515
13516 {
13517 int_T i;
13518 mxArray *plhs[1];
13519 mxArray *prhs[4];
13520 double *pr;
13521 volatile int_T *intS = (int_T *)&childS;
13522 int_T addrlen = sizeof(SimStruct *);
13523 int_T m = addrlen/sizeof(int_T) + 1;
13524 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
13525 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
13526 pr = mxGetPr(prhs[1]);
13527 for (i = 0; i < m - 1; i++) {
13528 pr[i] = (double)intS[i];
13529 }
13530
13531 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
13532 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
13533 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
13534
13535 /* Reset port dimensions info functions because the S-function
13536 * and accelerator mex-files explicitly set their dimensions,
13537 * i.e., they are not dynamically sized. For this case, the
13538 * mex-file is responsible for the dimensions info memory
13539 * and Simulink should not free it. This is achieved by
13540 * setting the following two methods to NULL.
13541 */
13542 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
13543 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
13544
13545 /*
13546 * Setup function pointers and call mdlInitializeSizes via
13547 * simulink.c
13548 */
13549 mexCallMATLAB(1, plhs, 4, prhs, "Fader_sf");
13550 mxDestroyArray(plhs[0]);
13551 mxDestroyArray(prhs[0]);
13552 mxDestroyArray(prhs[1]);
13553 mxDestroyArray(prhs[2]);
13554 mxDestroyArray(prhs[3]);
13555 }
13556
13557#else
13558
13559 {
13560 Fader_sf(childS);
13561 sfcnInitializeSizes(childS);
13562 }
13563
13564#endif
13565
13566 sfcnInitializeSampleTimes(childS);
13567
13568 /* adjust sample time */
13569 ssSetSampleTime(childS, 0, 0.0);
13570 ssSetOffsetTime(childS, 0, 0.0);
13571 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
13572
13573 /* set compiled values of dynamic vector attributes */
13574 ssSetNumNonsampledZCs(childS, 0);
13575
13576 /* Update connectivity flags for each port */
13577 _ssSetInputPortConnected(childS, 0, 1);
13578 _ssSetInputPortConnected(childS, 1, 1);
13579 _ssSetInputPortConnected(childS, 2, 1);
13580 _ssSetInputPortConnected(childS, 3, 1);
13581 _ssSetInputPortConnected(childS, 4, 1);
13582 _ssSetInputPortConnected(childS, 5, 1);
13583 _ssSetOutputPortConnected(childS, 0, 1);
13584 _ssSetOutputPortBeingMerged(childS, 0, 0);
13585
13586 /* Update the BufferDstPort flags for each input port */
13587 _ssSetInputPortBufferDstPort(childS, 0, -1);
13588 _ssSetInputPortBufferDstPort(childS, 1, -1);
13589 _ssSetInputPortBufferDstPort(childS, 2, -1);
13590 _ssSetInputPortBufferDstPort(childS, 3, -1);
13591 _ssSetInputPortBufferDstPort(childS, 4, -1);
13592 _ssSetInputPortBufferDstPort(childS, 5, -1);
13593 }
13594
13595 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S130>/Generated S-Function4 (LagFilter_sf) */
13596 {
13597 SimStruct *childS = ssGetSFunction(rts, 50);
13598
13599 /* timing info */
13600 time_T *sfcnPeriod;
13601 time_T *sfcnOffset;
13602 int_T *sfcnTsMap;
13603 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
13604 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
13605 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
13606 ss_VALIDATE_MEMORY(rts,sfcnOffset);
13607 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
13608 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
13609 (void) memset((void*)sfcnPeriod, 0,
13610 sizeof(time_T)*1);
13611 (void) memset((void*)sfcnOffset, 0,
13612 sizeof(time_T)*1);
13613 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
13614 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
13615 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
13616
13617 /* Set up the mdlInfo pointer */
13618# ifdef USE_RTMODEL
13619
13620 {
13621 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
13622 struct _ssBlkInfo2));
13623 ss_VALIDATE_MEMORY(rts,blkInfo2);
13624 ssSetBlkInfo2Ptr(childS, blkInfo2);
13625 }
13626
13627 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
13628
13629# else
13630
13631 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
13632
13633# endif /* USE_RTMODEL */
13634
13635 /* Allocate memory of model methods 2 */
13636 {
13637 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
13638 malloc(sizeof(struct _ssSFcnModelMethods2));
13639 ss_VALIDATE_MEMORY(rts,methods2);
13640 ssSetModelMethods2(childS, methods2);
13641 }
13642
13643 /* Allocate memory of model methods 3 */
13644 {
13645 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
13646 malloc(sizeof(struct _ssSFcnModelMethods3));
13647 ss_VALIDATE_MEMORY(rts,methods3);
13648 ssSetModelMethods3(childS, methods3);
13649 }
13650
13651 /* Allocate memory for states auxilliary information */
13652 {
13653 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
13654 (sizeof(struct _ssStatesInfo2));
13655 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
13656 malloc(sizeof(ssPeriodicStatesInfo));
13657 ss_VALIDATE_MEMORY(rts,statesInfo2);
13658 ssSetStatesInfo2(childS, statesInfo2);
13659 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
13660 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
13661 }
13662
13663 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
13664 RegNumInputPorts);
13665 ssSetRegNumInputPortsFcnArg(childS,childS);
13666
13667 /* inputs */
13668 {
13669 struct _ssPortInputs *inputPortInfo =
13670 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
13671 ss_VALIDATE_MEMORY(rts,inputPortInfo);
13672 _ssSetNumInputPorts(childS, 6);
13673 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
13674
13675 /* port 0 */
13676 {
13677 real32_T const **sfcnUPtrs = (real32_T const **)
13678 malloc(1 * sizeof(real32_T *));
13679 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13680 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13681 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
13682 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
13683 _ssSetInputPortNumDimensions(childS, 0, 1);
13684 ssSetInputPortWidth(childS, 0, 1);
13685 }
13686
13687 /* port 1 */
13688 {
13689 int8_T const **sfcnUPtrs = (int8_T const **)
13690 malloc(1 * sizeof(int8_T *));
13691 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13692 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
13693 ssGetLocalBlockIO(rts))->DataTypeConversion5_n;
13694 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
13695 _ssSetInputPortNumDimensions(childS, 1, 1);
13696 ssSetInputPortWidth(childS, 1, 1);
13697 }
13698
13699 /* port 2 */
13700 {
13701 real32_T const **sfcnUPtrs = (real32_T const **)
13702 malloc(1 * sizeof(real32_T *));
13703 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13704 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
13705 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
13706 _ssSetInputPortNumDimensions(childS, 2, 1);
13707 ssSetInputPortWidth(childS, 2, 1);
13708 }
13709
13710 /* port 3 */
13711 {
13712 real32_T const **sfcnUPtrs = (real32_T const **)
13713 malloc(1 * sizeof(real32_T *));
13714 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13715 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13716 ssGetLocalBlockIO(rts))->Switch_bg;
13717 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
13718 _ssSetInputPortNumDimensions(childS, 3, 1);
13719 ssSetInputPortWidth(childS, 3, 1);
13720 }
13721
13722 /* port 4 */
13723 {
13724 real32_T const **sfcnUPtrs = (real32_T const **)
13725 malloc(1 * sizeof(real32_T *));
13726 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13727 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13728 ssGetLocalBlockIO(rts))->Switch_bg;
13729 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
13730 _ssSetInputPortNumDimensions(childS, 4, 1);
13731 ssSetInputPortWidth(childS, 4, 1);
13732 }
13733
13734 /* port 5 */
13735 {
13736 real32_T const **sfcnUPtrs = (real32_T const **)
13737 malloc(1 * sizeof(real32_T *));
13738 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13739 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
13740 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
13741 _ssSetInputPortNumDimensions(childS, 5, 1);
13742 ssSetInputPortWidth(childS, 5, 1);
13743 }
13744 }
13745
13746 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
13747 RegNumOutputPorts);
13748 ssSetRegNumOutputPortsFcnArg(childS,childS);
13749
13750 /* outputs */
13751 {
13752 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
13753 calloc(1, sizeof(struct _ssPortOutputs));
13754 ss_VALIDATE_MEMORY(rts,outputPortInfo);
13755 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
13756 _ssSetNumOutputPorts(childS, 1);
13757
13758 /* port 0 */
13759 {
13760 _ssSetOutputPortNumDimensions(childS, 0, 1);
13761 ssSetOutputPortWidth(childS, 0, 1);
13762 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
13763 ssGetLocalBlockIO(rts))->GeneratedSFunction4_b));
13764 }
13765 }
13766
13767 /* path info */
13768 _ssSetModelName(childS, "LagFilter_sf");
13769 _ssSetPath(childS,
13770 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PLControl/ lag filter/Generated S-Function4");
13771 if (ssGetRTModel(rts) == (NULL)) {
13772 _ssSetParentSS(childS, rts);
13773 _ssSetRootSS(childS, ssGetRootSS(rts));
13774 } else {
13775 ssSetRTModel(childS,ssGetRTModel(rts));
13776 _ssSetParentSS(childS, (NULL));
13777 _ssSetRootSS(childS, childS);
13778 }
13779
13780 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
13781
13782 /* work vectors */
13783 {
13784 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
13785 (4 * sizeof(struct _ssDWorkRecord));
13786 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
13787 calloc(4, sizeof(struct _ssDWorkAuxRecord));
13788 ss_VALIDATE_MEMORY(rts,dWorkRecord);
13789 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
13790 ssSetSFcnDWork(childS, dWorkRecord);
13791 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
13792 _ssSetNumDWork(childS, 4);
13793
13794 /* DWORK0 */
13795 ssSetDWorkWidth(childS, 0, 1);
13796 ssSetDWorkDataType(childS, 0,SS_SINGLE);
13797 ssSetDWorkComplexSignal(childS, 0, 0);
13798 ssSetDWorkUsedAsDState(childS, 0, 1);
13799 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 189))[0]);
13800
13801 /* DWORK1 */
13802 ssSetDWorkWidth(childS, 1, 1);
13803 ssSetDWorkDataType(childS, 1,SS_SINGLE);
13804 ssSetDWorkComplexSignal(childS, 1, 0);
13805 ssSetDWorkUsedAsDState(childS, 1, 1);
13806 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 190))[0]);
13807
13808 /* DWORK2 */
13809 ssSetDWorkWidth(childS, 2, 1);
13810 ssSetDWorkDataType(childS, 2,SS_INT8);
13811 ssSetDWorkComplexSignal(childS, 2, 0);
13812 ssSetDWorkUsedAsDState(childS, 2, 1);
13813 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 417))[0]);
13814
13815 /* DWORK3 */
13816 ssSetDWorkWidth(childS, 3, 1);
13817 ssSetDWorkDataType(childS, 3,SS_INT8);
13818 ssSetDWorkComplexSignal(childS, 3, 0);
13819 ssSetDWorkUsedAsDState(childS, 3, 1);
13820 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 418))[0]);
13821 }
13822
13823 (childS)->regDataType.arg1 = ((void *)(childS));
13824 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
13825 FcnSetErrorStatus);
13826 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
13827 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
13828 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
13829 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
13830
13831 /* registration */
13832#if defined(MATLAB_MEX_FILE)
13833
13834 {
13835 int_T i;
13836 mxArray *plhs[1];
13837 mxArray *prhs[4];
13838 double *pr;
13839 volatile int_T *intS = (int_T *)&childS;
13840 int_T addrlen = sizeof(SimStruct *);
13841 int_T m = addrlen/sizeof(int_T) + 1;
13842 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
13843 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
13844 pr = mxGetPr(prhs[1]);
13845 for (i = 0; i < m - 1; i++) {
13846 pr[i] = (double)intS[i];
13847 }
13848
13849 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
13850 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
13851 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
13852
13853 /* Reset port dimensions info functions because the S-function
13854 * and accelerator mex-files explicitly set their dimensions,
13855 * i.e., they are not dynamically sized. For this case, the
13856 * mex-file is responsible for the dimensions info memory
13857 * and Simulink should not free it. This is achieved by
13858 * setting the following two methods to NULL.
13859 */
13860 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
13861 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
13862
13863 /*
13864 * Setup function pointers and call mdlInitializeSizes via
13865 * simulink.c
13866 */
13867 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
13868 mxDestroyArray(plhs[0]);
13869 mxDestroyArray(prhs[0]);
13870 mxDestroyArray(prhs[1]);
13871 mxDestroyArray(prhs[2]);
13872 mxDestroyArray(prhs[3]);
13873 }
13874
13875#else
13876
13877 {
13878 LagFilter_sf(childS);
13879 sfcnInitializeSizes(childS);
13880 }
13881
13882#endif
13883
13884 sfcnInitializeSampleTimes(childS);
13885
13886 /* adjust sample time */
13887 ssSetSampleTime(childS, 0, 0.0);
13888 ssSetOffsetTime(childS, 0, 0.0);
13889 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
13890
13891 /* set compiled values of dynamic vector attributes */
13892 ssSetNumNonsampledZCs(childS, 0);
13893
13894 /* Update connectivity flags for each port */
13895 _ssSetInputPortConnected(childS, 0, 1);
13896 _ssSetInputPortConnected(childS, 1, 1);
13897 _ssSetInputPortConnected(childS, 2, 1);
13898 _ssSetInputPortConnected(childS, 3, 1);
13899 _ssSetInputPortConnected(childS, 4, 1);
13900 _ssSetInputPortConnected(childS, 5, 1);
13901 _ssSetOutputPortConnected(childS, 0, 1);
13902 _ssSetOutputPortBeingMerged(childS, 0, 0);
13903
13904 /* Update the BufferDstPort flags for each input port */
13905 _ssSetInputPortBufferDstPort(childS, 0, -1);
13906 _ssSetInputPortBufferDstPort(childS, 1, -1);
13907 _ssSetInputPortBufferDstPort(childS, 2, -1);
13908 _ssSetInputPortBufferDstPort(childS, 3, -1);
13909 _ssSetInputPortBufferDstPort(childS, 4, -1);
13910 _ssSetInputPortBufferDstPort(childS, 5, -1);
13911 }
13912
13913 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S125>/Generated S-Function6 (Res180_sf) */
13914 {
13915 SimStruct *childS = ssGetSFunction(rts, 51);
13916
13917 /* timing info */
13918 time_T *sfcnPeriod;
13919 time_T *sfcnOffset;
13920 int_T *sfcnTsMap;
13921 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
13922 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
13923 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
13924 ss_VALIDATE_MEMORY(rts,sfcnOffset);
13925 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
13926 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
13927 (void) memset((void*)sfcnPeriod, 0,
13928 sizeof(time_T)*1);
13929 (void) memset((void*)sfcnOffset, 0,
13930 sizeof(time_T)*1);
13931 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
13932 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
13933 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
13934
13935 /* Set up the mdlInfo pointer */
13936# ifdef USE_RTMODEL
13937
13938 {
13939 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
13940 struct _ssBlkInfo2));
13941 ss_VALIDATE_MEMORY(rts,blkInfo2);
13942 ssSetBlkInfo2Ptr(childS, blkInfo2);
13943 }
13944
13945 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
13946
13947# else
13948
13949 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
13950
13951# endif /* USE_RTMODEL */
13952
13953 /* Allocate memory of model methods 2 */
13954 {
13955 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
13956 malloc(sizeof(struct _ssSFcnModelMethods2));
13957 ss_VALIDATE_MEMORY(rts,methods2);
13958 ssSetModelMethods2(childS, methods2);
13959 }
13960
13961 /* Allocate memory of model methods 3 */
13962 {
13963 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
13964 malloc(sizeof(struct _ssSFcnModelMethods3));
13965 ss_VALIDATE_MEMORY(rts,methods3);
13966 ssSetModelMethods3(childS, methods3);
13967 }
13968
13969 /* Allocate memory for states auxilliary information */
13970 {
13971 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
13972 (sizeof(struct _ssStatesInfo2));
13973 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
13974 malloc(sizeof(ssPeriodicStatesInfo));
13975 ss_VALIDATE_MEMORY(rts,statesInfo2);
13976 ssSetStatesInfo2(childS, statesInfo2);
13977 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
13978 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
13979 }
13980
13981 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
13982 RegNumInputPorts);
13983 ssSetRegNumInputPortsFcnArg(childS,childS);
13984
13985 /* inputs */
13986 {
13987 struct _ssPortInputs *inputPortInfo =
13988 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
13989 ss_VALIDATE_MEMORY(rts,inputPortInfo);
13990 _ssSetNumInputPorts(childS, 1);
13991 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
13992
13993 /* port 0 */
13994 {
13995 real32_T const **sfcnUPtrs = (real32_T const **)
13996 malloc(1 * sizeof(real32_T *));
13997 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
13998 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
13999 ssGetLocalBlockIO(rts))->Sum1_lf;
14000 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
14001 _ssSetInputPortNumDimensions(childS, 0, 1);
14002 ssSetInputPortWidth(childS, 0, 1);
14003 }
14004 }
14005
14006 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
14007 RegNumOutputPorts);
14008 ssSetRegNumOutputPortsFcnArg(childS,childS);
14009
14010 /* outputs */
14011 {
14012 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
14013 calloc(1, sizeof(struct _ssPortOutputs));
14014 ss_VALIDATE_MEMORY(rts,outputPortInfo);
14015 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
14016 _ssSetNumOutputPorts(childS, 1);
14017
14018 /* port 0 */
14019 {
14020 _ssSetOutputPortNumDimensions(childS, 0, 1);
14021 ssSetOutputPortWidth(childS, 0, 1);
14022 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
14023 ssGetLocalBlockIO(rts))->GeneratedSFunction6_h));
14024 }
14025 }
14026
14027 /* path info */
14028 _ssSetModelName(childS, "Res180_sf");
14029 _ssSetPath(childS,
14030 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/Generated S-Function6");
14031 if (ssGetRTModel(rts) == (NULL)) {
14032 _ssSetParentSS(childS, rts);
14033 _ssSetRootSS(childS, ssGetRootSS(rts));
14034 } else {
14035 ssSetRTModel(childS,ssGetRTModel(rts));
14036 _ssSetParentSS(childS, (NULL));
14037 _ssSetRootSS(childS, childS);
14038 }
14039
14040 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
14041 (childS)->regDataType.arg1 = ((void *)(childS));
14042 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
14043 FcnSetErrorStatus);
14044 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
14045 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
14046 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
14047 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
14048
14049 /* registration */
14050#if defined(MATLAB_MEX_FILE)
14051
14052 {
14053 int_T i;
14054 mxArray *plhs[1];
14055 mxArray *prhs[4];
14056 double *pr;
14057 volatile int_T *intS = (int_T *)&childS;
14058 int_T addrlen = sizeof(SimStruct *);
14059 int_T m = addrlen/sizeof(int_T) + 1;
14060 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
14061 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
14062 pr = mxGetPr(prhs[1]);
14063 for (i = 0; i < m - 1; i++) {
14064 pr[i] = (double)intS[i];
14065 }
14066
14067 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
14068 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
14069 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
14070
14071 /* Reset port dimensions info functions because the S-function
14072 * and accelerator mex-files explicitly set their dimensions,
14073 * i.e., they are not dynamically sized. For this case, the
14074 * mex-file is responsible for the dimensions info memory
14075 * and Simulink should not free it. This is achieved by
14076 * setting the following two methods to NULL.
14077 */
14078 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
14079 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
14080
14081 /*
14082 * Setup function pointers and call mdlInitializeSizes via
14083 * simulink.c
14084 */
14085 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
14086 mxDestroyArray(plhs[0]);
14087 mxDestroyArray(prhs[0]);
14088 mxDestroyArray(prhs[1]);
14089 mxDestroyArray(prhs[2]);
14090 mxDestroyArray(prhs[3]);
14091 }
14092
14093#else
14094
14095 {
14096 Res180_sf(childS);
14097 sfcnInitializeSizes(childS);
14098 }
14099
14100#endif
14101
14102 sfcnInitializeSampleTimes(childS);
14103
14104 /* adjust sample time */
14105 ssSetSampleTime(childS, 0, 0.0);
14106 ssSetOffsetTime(childS, 0, 0.0);
14107 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
14108
14109 /* set compiled values of dynamic vector attributes */
14110 ssSetNumNonsampledZCs(childS, 0);
14111
14112 /* Update connectivity flags for each port */
14113 _ssSetInputPortConnected(childS, 0, 1);
14114 _ssSetOutputPortConnected(childS, 0, 1);
14115 _ssSetOutputPortBeingMerged(childS, 0, 0);
14116
14117 /* Update the BufferDstPort flags for each input port */
14118 _ssSetInputPortBufferDstPort(childS, 0, -1);
14119 }
14120
14121 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S134>/Generated S-Function1 (SaturationLimiter_sf) */
14122 {
14123 SimStruct *childS = ssGetSFunction(rts, 52);
14124
14125 /* timing info */
14126 time_T *sfcnPeriod;
14127 time_T *sfcnOffset;
14128 int_T *sfcnTsMap;
14129 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
14130 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
14131 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
14132 ss_VALIDATE_MEMORY(rts,sfcnOffset);
14133 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
14134 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
14135 (void) memset((void*)sfcnPeriod, 0,
14136 sizeof(time_T)*1);
14137 (void) memset((void*)sfcnOffset, 0,
14138 sizeof(time_T)*1);
14139 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
14140 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
14141 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
14142
14143 /* Set up the mdlInfo pointer */
14144# ifdef USE_RTMODEL
14145
14146 {
14147 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
14148 struct _ssBlkInfo2));
14149 ss_VALIDATE_MEMORY(rts,blkInfo2);
14150 ssSetBlkInfo2Ptr(childS, blkInfo2);
14151 }
14152
14153 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
14154
14155# else
14156
14157 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
14158
14159# endif /* USE_RTMODEL */
14160
14161 /* Allocate memory of model methods 2 */
14162 {
14163 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
14164 malloc(sizeof(struct _ssSFcnModelMethods2));
14165 ss_VALIDATE_MEMORY(rts,methods2);
14166 ssSetModelMethods2(childS, methods2);
14167 }
14168
14169 /* Allocate memory of model methods 3 */
14170 {
14171 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
14172 malloc(sizeof(struct _ssSFcnModelMethods3));
14173 ss_VALIDATE_MEMORY(rts,methods3);
14174 ssSetModelMethods3(childS, methods3);
14175 }
14176
14177 /* Allocate memory for states auxilliary information */
14178 {
14179 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
14180 (sizeof(struct _ssStatesInfo2));
14181 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
14182 malloc(sizeof(ssPeriodicStatesInfo));
14183 ss_VALIDATE_MEMORY(rts,statesInfo2);
14184 ssSetStatesInfo2(childS, statesInfo2);
14185 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
14186 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
14187 }
14188
14189 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
14190 RegNumInputPorts);
14191 ssSetRegNumInputPortsFcnArg(childS,childS);
14192
14193 /* inputs */
14194 {
14195 struct _ssPortInputs *inputPortInfo =
14196 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
14197 ss_VALIDATE_MEMORY(rts,inputPortInfo);
14198 _ssSetNumInputPorts(childS, 3);
14199 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
14200
14201 /* port 0 */
14202 {
14203 real32_T const **sfcnUPtrs = (real32_T const **)
14204 malloc(1 * sizeof(real32_T *));
14205 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
14206 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
14207 ssGetLocalBlockIO(rts))->GeneratedSFunction6_h;
14208 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
14209 _ssSetInputPortNumDimensions(childS, 0, 1);
14210 ssSetInputPortWidth(childS, 0, 1);
14211 }
14212
14213 /* port 1 */
14214 {
14215 real32_T const **sfcnUPtrs = (real32_T const **)
14216 malloc(1 * sizeof(real32_T *));
14217 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
14218 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
14219 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
14220 _ssSetInputPortNumDimensions(childS, 1, 1);
14221 ssSetInputPortWidth(childS, 1, 1);
14222 }
14223
14224 /* port 2 */
14225 {
14226 real32_T const **sfcnUPtrs = (real32_T const **)
14227 malloc(1 * sizeof(real32_T *));
14228 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
14229 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;
14230 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
14231 _ssSetInputPortNumDimensions(childS, 2, 1);
14232 ssSetInputPortWidth(childS, 2, 1);
14233 }
14234 }
14235
14236 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
14237 RegNumOutputPorts);
14238 ssSetRegNumOutputPortsFcnArg(childS,childS);
14239
14240 /* outputs */
14241 {
14242 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
14243 calloc(1, sizeof(struct _ssPortOutputs));
14244 ss_VALIDATE_MEMORY(rts,outputPortInfo);
14245 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
14246 _ssSetNumOutputPorts(childS, 1);
14247
14248 /* port 0 */
14249 {
14250 _ssSetOutputPortNumDimensions(childS, 0, 1);
14251 ssSetOutputPortWidth(childS, 0, 1);
14252 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
14253 ssGetLocalBlockIO(rts))->GeneratedSFunction1_c));
14254 }
14255 }
14256
14257 /* path info */
14258 _ssSetModelName(childS, "SaturationLimiter_sf");
14259 _ssSetPath(childS,
14260 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/Saturation Limiter/Generated S-Function1");
14261 if (ssGetRTModel(rts) == (NULL)) {
14262 _ssSetParentSS(childS, rts);
14263 _ssSetRootSS(childS, ssGetRootSS(rts));
14264 } else {
14265 ssSetRTModel(childS,ssGetRTModel(rts));
14266 _ssSetParentSS(childS, (NULL));
14267 _ssSetRootSS(childS, childS);
14268 }
14269
14270 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
14271 (childS)->regDataType.arg1 = ((void *)(childS));
14272 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
14273 FcnSetErrorStatus);
14274 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
14275 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
14276 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
14277 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
14278
14279 /* registration */
14280#if defined(MATLAB_MEX_FILE)
14281
14282 {
14283 int_T i;
14284 mxArray *plhs[1];
14285 mxArray *prhs[4];
14286 double *pr;
14287 volatile int_T *intS = (int_T *)&childS;
14288 int_T addrlen = sizeof(SimStruct *);
14289 int_T m = addrlen/sizeof(int_T) + 1;
14290 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
14291 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
14292 pr = mxGetPr(prhs[1]);
14293 for (i = 0; i < m - 1; i++) {
14294 pr[i] = (double)intS[i];
14295 }
14296
14297 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
14298 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
14299 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
14300
14301 /* Reset port dimensions info functions because the S-function
14302 * and accelerator mex-files explicitly set their dimensions,
14303 * i.e., they are not dynamically sized. For this case, the
14304 * mex-file is responsible for the dimensions info memory
14305 * and Simulink should not free it. This is achieved by
14306 * setting the following two methods to NULL.
14307 */
14308 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
14309 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
14310
14311 /*
14312 * Setup function pointers and call mdlInitializeSizes via
14313 * simulink.c
14314 */
14315 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
14316 mxDestroyArray(plhs[0]);
14317 mxDestroyArray(prhs[0]);
14318 mxDestroyArray(prhs[1]);
14319 mxDestroyArray(prhs[2]);
14320 mxDestroyArray(prhs[3]);
14321 }
14322
14323#else
14324
14325 {
14326 SaturationLimiter_sf(childS);
14327 sfcnInitializeSizes(childS);
14328 }
14329
14330#endif
14331
14332 sfcnInitializeSampleTimes(childS);
14333
14334 /* adjust sample time */
14335 ssSetSampleTime(childS, 0, 0.0);
14336 ssSetOffsetTime(childS, 0, 0.0);
14337 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
14338
14339 /* set compiled values of dynamic vector attributes */
14340 ssSetNumNonsampledZCs(childS, 0);
14341
14342 /* Update connectivity flags for each port */
14343 _ssSetInputPortConnected(childS, 0, 1);
14344 _ssSetInputPortConnected(childS, 1, 1);
14345 _ssSetInputPortConnected(childS, 2, 1);
14346 _ssSetOutputPortConnected(childS, 0, 1);
14347 _ssSetOutputPortBeingMerged(childS, 0, 0);
14348
14349 /* Update the BufferDstPort flags for each input port */
14350 _ssSetInputPortBufferDstPort(childS, 0, -1);
14351 _ssSetInputPortBufferDstPort(childS, 1, -1);
14352 _ssSetInputPortBufferDstPort(childS, 2, -1);
14353 }
14354
14355 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S135>/Generated S-Function (Gain_sf) */
14356 {
14357 SimStruct *childS = ssGetSFunction(rts, 53);
14358
14359 /* timing info */
14360 time_T *sfcnPeriod;
14361 time_T *sfcnOffset;
14362 int_T *sfcnTsMap;
14363 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
14364 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
14365 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
14366 ss_VALIDATE_MEMORY(rts,sfcnOffset);
14367 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
14368 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
14369 (void) memset((void*)sfcnPeriod, 0,
14370 sizeof(time_T)*1);
14371 (void) memset((void*)sfcnOffset, 0,
14372 sizeof(time_T)*1);
14373 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
14374 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
14375 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
14376
14377 /* Set up the mdlInfo pointer */
14378# ifdef USE_RTMODEL
14379
14380 {
14381 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
14382 struct _ssBlkInfo2));
14383 ss_VALIDATE_MEMORY(rts,blkInfo2);
14384 ssSetBlkInfo2Ptr(childS, blkInfo2);
14385 }
14386
14387 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
14388
14389# else
14390
14391 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
14392
14393# endif /* USE_RTMODEL */
14394
14395 /* Allocate memory of model methods 2 */
14396 {
14397 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
14398 malloc(sizeof(struct _ssSFcnModelMethods2));
14399 ss_VALIDATE_MEMORY(rts,methods2);
14400 ssSetModelMethods2(childS, methods2);
14401 }
14402
14403 /* Allocate memory of model methods 3 */
14404 {
14405 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
14406 malloc(sizeof(struct _ssSFcnModelMethods3));
14407 ss_VALIDATE_MEMORY(rts,methods3);
14408 ssSetModelMethods3(childS, methods3);
14409 }
14410
14411 /* Allocate memory for states auxilliary information */
14412 {
14413 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
14414 (sizeof(struct _ssStatesInfo2));
14415 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
14416 malloc(sizeof(ssPeriodicStatesInfo));
14417 ss_VALIDATE_MEMORY(rts,statesInfo2);
14418 ssSetStatesInfo2(childS, statesInfo2);
14419 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
14420 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
14421 }
14422
14423 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
14424 RegNumInputPorts);
14425 ssSetRegNumInputPortsFcnArg(childS,childS);
14426
14427 /* inputs */
14428 {
14429 struct _ssPortInputs *inputPortInfo =
14430 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
14431 ss_VALIDATE_MEMORY(rts,inputPortInfo);
14432 _ssSetNumInputPorts(childS, 2);
14433 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
14434
14435 /* port 0 */
14436 {
14437 real32_T const **sfcnUPtrs = (real32_T const **)
14438 malloc(1 * sizeof(real32_T *));
14439 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
14440 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
14441 ssGetLocalBlockIO(rts))->GeneratedSFunction1_c;
14442 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
14443 _ssSetInputPortNumDimensions(childS, 0, 1);
14444 ssSetInputPortWidth(childS, 0, 1);
14445 }
14446
14447 /* port 1 */
14448 {
14449 real32_T const **sfcnUPtrs = (real32_T const **)
14450 malloc(1 * sizeof(real32_T *));
14451 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
14452 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
14453 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
14454 _ssSetInputPortNumDimensions(childS, 1, 1);
14455 ssSetInputPortWidth(childS, 1, 1);
14456 }
14457 }
14458
14459 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
14460 RegNumOutputPorts);
14461 ssSetRegNumOutputPortsFcnArg(childS,childS);
14462
14463 /* outputs */
14464 {
14465 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
14466 calloc(1, sizeof(struct _ssPortOutputs));
14467 ss_VALIDATE_MEMORY(rts,outputPortInfo);
14468 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
14469 _ssSetNumOutputPorts(childS, 1);
14470
14471 /* port 0 */
14472 {
14473 _ssSetOutputPortNumDimensions(childS, 0, 1);
14474 ssSetOutputPortWidth(childS, 0, 1);
14475 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
14476 ssGetLocalBlockIO(rts))->GeneratedSFunction_hw));
14477 }
14478 }
14479
14480 /* path info */
14481 _ssSetModelName(childS, "Gain_sf");
14482 _ssSetPath(childS,
14483 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/gain/Generated S-Function");
14484 if (ssGetRTModel(rts) == (NULL)) {
14485 _ssSetParentSS(childS, rts);
14486 _ssSetRootSS(childS, ssGetRootSS(rts));
14487 } else {
14488 ssSetRTModel(childS,ssGetRTModel(rts));
14489 _ssSetParentSS(childS, (NULL));
14490 _ssSetRootSS(childS, childS);
14491 }
14492
14493 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
14494 (childS)->regDataType.arg1 = ((void *)(childS));
14495 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
14496 FcnSetErrorStatus);
14497 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
14498 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
14499 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
14500 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
14501
14502 /* registration */
14503#if defined(MATLAB_MEX_FILE)
14504
14505 {
14506 int_T i;
14507 mxArray *plhs[1];
14508 mxArray *prhs[4];
14509 double *pr;
14510 volatile int_T *intS = (int_T *)&childS;
14511 int_T addrlen = sizeof(SimStruct *);
14512 int_T m = addrlen/sizeof(int_T) + 1;
14513 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
14514 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
14515 pr = mxGetPr(prhs[1]);
14516 for (i = 0; i < m - 1; i++) {
14517 pr[i] = (double)intS[i];
14518 }
14519
14520 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
14521 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
14522 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
14523
14524 /* Reset port dimensions info functions because the S-function
14525 * and accelerator mex-files explicitly set their dimensions,
14526 * i.e., they are not dynamically sized. For this case, the
14527 * mex-file is responsible for the dimensions info memory
14528 * and Simulink should not free it. This is achieved by
14529 * setting the following two methods to NULL.
14530 */
14531 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
14532 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
14533
14534 /*
14535 * Setup function pointers and call mdlInitializeSizes via
14536 * simulink.c
14537 */
14538 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
14539 mxDestroyArray(plhs[0]);
14540 mxDestroyArray(prhs[0]);
14541 mxDestroyArray(prhs[1]);
14542 mxDestroyArray(prhs[2]);
14543 mxDestroyArray(prhs[3]);
14544 }
14545
14546#else
14547
14548 {
14549 Gain_sf(childS);
14550 sfcnInitializeSizes(childS);
14551 }
14552
14553#endif
14554
14555 sfcnInitializeSampleTimes(childS);
14556
14557 /* adjust sample time */
14558 ssSetSampleTime(childS, 0, 0.0);
14559 ssSetOffsetTime(childS, 0, 0.0);
14560 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
14561
14562 /* set compiled values of dynamic vector attributes */
14563 ssSetNumNonsampledZCs(childS, 0);
14564
14565 /* Update connectivity flags for each port */
14566 _ssSetInputPortConnected(childS, 0, 1);
14567 _ssSetInputPortConnected(childS, 1, 1);
14568 _ssSetOutputPortConnected(childS, 0, 1);
14569 _ssSetOutputPortBeingMerged(childS, 0, 0);
14570
14571 /* Update the BufferDstPort flags for each input port */
14572 _ssSetInputPortBufferDstPort(childS, 0, -1);
14573 _ssSetInputPortBufferDstPort(childS, 1, -1);
14574 }
14575
14576 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S136>/Generated S-Function (Gain_sf) */
14577 {
14578 SimStruct *childS = ssGetSFunction(rts, 54);
14579
14580 /* timing info */
14581 time_T *sfcnPeriod;
14582 time_T *sfcnOffset;
14583 int_T *sfcnTsMap;
14584 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
14585 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
14586 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
14587 ss_VALIDATE_MEMORY(rts,sfcnOffset);
14588 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
14589 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
14590 (void) memset((void*)sfcnPeriod, 0,
14591 sizeof(time_T)*1);
14592 (void) memset((void*)sfcnOffset, 0,
14593 sizeof(time_T)*1);
14594 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
14595 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
14596 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
14597
14598 /* Set up the mdlInfo pointer */
14599# ifdef USE_RTMODEL
14600
14601 {
14602 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
14603 struct _ssBlkInfo2));
14604 ss_VALIDATE_MEMORY(rts,blkInfo2);
14605 ssSetBlkInfo2Ptr(childS, blkInfo2);
14606 }
14607
14608 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
14609
14610# else
14611
14612 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
14613
14614# endif /* USE_RTMODEL */
14615
14616 /* Allocate memory of model methods 2 */
14617 {
14618 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
14619 malloc(sizeof(struct _ssSFcnModelMethods2));
14620 ss_VALIDATE_MEMORY(rts,methods2);
14621 ssSetModelMethods2(childS, methods2);
14622 }
14623
14624 /* Allocate memory of model methods 3 */
14625 {
14626 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
14627 malloc(sizeof(struct _ssSFcnModelMethods3));
14628 ss_VALIDATE_MEMORY(rts,methods3);
14629 ssSetModelMethods3(childS, methods3);
14630 }
14631
14632 /* Allocate memory for states auxilliary information */
14633 {
14634 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
14635 (sizeof(struct _ssStatesInfo2));
14636 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
14637 malloc(sizeof(ssPeriodicStatesInfo));
14638 ss_VALIDATE_MEMORY(rts,statesInfo2);
14639 ssSetStatesInfo2(childS, statesInfo2);
14640 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
14641 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
14642 }
14643
14644 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
14645 RegNumInputPorts);
14646 ssSetRegNumInputPortsFcnArg(childS,childS);
14647
14648 /* inputs */
14649 {
14650 struct _ssPortInputs *inputPortInfo =
14651 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
14652 ss_VALIDATE_MEMORY(rts,inputPortInfo);
14653 _ssSetNumInputPorts(childS, 2);
14654 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
14655
14656 /* port 0 */
14657 {
14658 real32_T const **sfcnUPtrs = (real32_T const **)
14659 malloc(1 * sizeof(real32_T *));
14660 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
14661 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
14662 ssGetLocalBlockIO(rts))->GeneratedSFunction_hw;
14663 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
14664 _ssSetInputPortNumDimensions(childS, 0, 1);
14665 ssSetInputPortWidth(childS, 0, 1);
14666 }
14667
14668 /* port 1 */
14669 {
14670 real32_T const **sfcnUPtrs = (real32_T const **)
14671 malloc(1 * sizeof(real32_T *));
14672 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
14673 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
14674 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
14675 _ssSetInputPortNumDimensions(childS, 1, 1);
14676 ssSetInputPortWidth(childS, 1, 1);
14677 }
14678 }
14679
14680 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
14681 RegNumOutputPorts);
14682 ssSetRegNumOutputPortsFcnArg(childS,childS);
14683
14684 /* outputs */
14685 {
14686 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
14687 calloc(1, sizeof(struct _ssPortOutputs));
14688 ss_VALIDATE_MEMORY(rts,outputPortInfo);
14689 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
14690 _ssSetNumOutputPorts(childS, 1);
14691
14692 /* port 0 */
14693 {
14694 _ssSetOutputPortNumDimensions(childS, 0, 1);
14695 ssSetOutputPortWidth(childS, 0, 1);
14696 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
14697 ssGetLocalBlockIO(rts))->MinMax));
14698 }
14699 }
14700
14701 /* path info */
14702 _ssSetModelName(childS, "Gain_sf");
14703 _ssSetPath(childS,
14704 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/gain1/Generated S-Function");
14705 if (ssGetRTModel(rts) == (NULL)) {
14706 _ssSetParentSS(childS, rts);
14707 _ssSetRootSS(childS, ssGetRootSS(rts));
14708 } else {
14709 ssSetRTModel(childS,ssGetRTModel(rts));
14710 _ssSetParentSS(childS, (NULL));
14711 _ssSetRootSS(childS, childS);
14712 }
14713
14714 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
14715 (childS)->regDataType.arg1 = ((void *)(childS));
14716 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
14717 FcnSetErrorStatus);
14718 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
14719 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
14720 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
14721 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
14722
14723 /* registration */
14724#if defined(MATLAB_MEX_FILE)
14725
14726 {
14727 int_T i;
14728 mxArray *plhs[1];
14729 mxArray *prhs[4];
14730 double *pr;
14731 volatile int_T *intS = (int_T *)&childS;
14732 int_T addrlen = sizeof(SimStruct *);
14733 int_T m = addrlen/sizeof(int_T) + 1;
14734 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
14735 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
14736 pr = mxGetPr(prhs[1]);
14737 for (i = 0; i < m - 1; i++) {
14738 pr[i] = (double)intS[i];
14739 }
14740
14741 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
14742 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
14743 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
14744
14745 /* Reset port dimensions info functions because the S-function
14746 * and accelerator mex-files explicitly set their dimensions,
14747 * i.e., they are not dynamically sized. For this case, the
14748 * mex-file is responsible for the dimensions info memory
14749 * and Simulink should not free it. This is achieved by
14750 * setting the following two methods to NULL.
14751 */
14752 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
14753 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
14754
14755 /*
14756 * Setup function pointers and call mdlInitializeSizes via
14757 * simulink.c
14758 */
14759 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
14760 mxDestroyArray(plhs[0]);
14761 mxDestroyArray(prhs[0]);
14762 mxDestroyArray(prhs[1]);
14763 mxDestroyArray(prhs[2]);
14764 mxDestroyArray(prhs[3]);
14765 }
14766
14767#else
14768
14769 {
14770 Gain_sf(childS);
14771 sfcnInitializeSizes(childS);
14772 }
14773
14774#endif
14775
14776 sfcnInitializeSampleTimes(childS);
14777
14778 /* adjust sample time */
14779 ssSetSampleTime(childS, 0, 0.0);
14780 ssSetOffsetTime(childS, 0, 0.0);
14781 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
14782
14783 /* set compiled values of dynamic vector attributes */
14784 ssSetNumNonsampledZCs(childS, 0);
14785
14786 /* Update connectivity flags for each port */
14787 _ssSetInputPortConnected(childS, 0, 1);
14788 _ssSetInputPortConnected(childS, 1, 1);
14789 _ssSetOutputPortConnected(childS, 0, 1);
14790 _ssSetOutputPortBeingMerged(childS, 0, 0);
14791
14792 /* Update the BufferDstPort flags for each input port */
14793 _ssSetInputPortBufferDstPort(childS, 0, -1);
14794 _ssSetInputPortBufferDstPort(childS, 1, -1);
14795 }
14796
14797 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S137>/Generated S-Function (Gain_sf) */
14798 {
14799 SimStruct *childS = ssGetSFunction(rts, 55);
14800
14801 /* timing info */
14802 time_T *sfcnPeriod;
14803 time_T *sfcnOffset;
14804 int_T *sfcnTsMap;
14805 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
14806 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
14807 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
14808 ss_VALIDATE_MEMORY(rts,sfcnOffset);
14809 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
14810 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
14811 (void) memset((void*)sfcnPeriod, 0,
14812 sizeof(time_T)*1);
14813 (void) memset((void*)sfcnOffset, 0,
14814 sizeof(time_T)*1);
14815 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
14816 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
14817 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
14818
14819 /* Set up the mdlInfo pointer */
14820# ifdef USE_RTMODEL
14821
14822 {
14823 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
14824 struct _ssBlkInfo2));
14825 ss_VALIDATE_MEMORY(rts,blkInfo2);
14826 ssSetBlkInfo2Ptr(childS, blkInfo2);
14827 }
14828
14829 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
14830
14831# else
14832
14833 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
14834
14835# endif /* USE_RTMODEL */
14836
14837 /* Allocate memory of model methods 2 */
14838 {
14839 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
14840 malloc(sizeof(struct _ssSFcnModelMethods2));
14841 ss_VALIDATE_MEMORY(rts,methods2);
14842 ssSetModelMethods2(childS, methods2);
14843 }
14844
14845 /* Allocate memory of model methods 3 */
14846 {
14847 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
14848 malloc(sizeof(struct _ssSFcnModelMethods3));
14849 ss_VALIDATE_MEMORY(rts,methods3);
14850 ssSetModelMethods3(childS, methods3);
14851 }
14852
14853 /* Allocate memory for states auxilliary information */
14854 {
14855 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
14856 (sizeof(struct _ssStatesInfo2));
14857 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
14858 malloc(sizeof(ssPeriodicStatesInfo));
14859 ss_VALIDATE_MEMORY(rts,statesInfo2);
14860 ssSetStatesInfo2(childS, statesInfo2);
14861 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
14862 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
14863 }
14864
14865 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
14866 RegNumInputPorts);
14867 ssSetRegNumInputPortsFcnArg(childS,childS);
14868
14869 /* inputs */
14870 {
14871 struct _ssPortInputs *inputPortInfo =
14872 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
14873 ss_VALIDATE_MEMORY(rts,inputPortInfo);
14874 _ssSetNumInputPorts(childS, 2);
14875 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
14876
14877 /* port 0 */
14878 {
14879 real32_T const **sfcnUPtrs = (real32_T const **)
14880 malloc(1 * sizeof(real32_T *));
14881 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
14882 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
14883 ssGetLocalBlockIO(rts))->UnitDelay1_k;
14884 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
14885 _ssSetInputPortNumDimensions(childS, 0, 1);
14886 ssSetInputPortWidth(childS, 0, 1);
14887 }
14888
14889 /* port 1 */
14890 {
14891 real32_T const **sfcnUPtrs = (real32_T const **)
14892 malloc(1 * sizeof(real32_T *));
14893 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
14894 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
14895 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
14896 _ssSetInputPortNumDimensions(childS, 1, 1);
14897 ssSetInputPortWidth(childS, 1, 1);
14898 }
14899 }
14900
14901 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
14902 RegNumOutputPorts);
14903 ssSetRegNumOutputPortsFcnArg(childS,childS);
14904
14905 /* outputs */
14906 {
14907 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
14908 calloc(1, sizeof(struct _ssPortOutputs));
14909 ss_VALIDATE_MEMORY(rts,outputPortInfo);
14910 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
14911 _ssSetNumOutputPorts(childS, 1);
14912
14913 /* port 0 */
14914 {
14915 _ssSetOutputPortNumDimensions(childS, 0, 1);
14916 ssSetOutputPortWidth(childS, 0, 1);
14917 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
14918 ssGetLocalBlockIO(rts))->GeneratedSFunction_a));
14919 }
14920 }
14921
14922 /* path info */
14923 _ssSetModelName(childS, "Gain_sf");
14924 _ssSetPath(childS,
14925 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/gain8/Generated S-Function");
14926 if (ssGetRTModel(rts) == (NULL)) {
14927 _ssSetParentSS(childS, rts);
14928 _ssSetRootSS(childS, ssGetRootSS(rts));
14929 } else {
14930 ssSetRTModel(childS,ssGetRTModel(rts));
14931 _ssSetParentSS(childS, (NULL));
14932 _ssSetRootSS(childS, childS);
14933 }
14934
14935 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
14936 (childS)->regDataType.arg1 = ((void *)(childS));
14937 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
14938 FcnSetErrorStatus);
14939 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
14940 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
14941 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
14942 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
14943
14944 /* registration */
14945#if defined(MATLAB_MEX_FILE)
14946
14947 {
14948 int_T i;
14949 mxArray *plhs[1];
14950 mxArray *prhs[4];
14951 double *pr;
14952 volatile int_T *intS = (int_T *)&childS;
14953 int_T addrlen = sizeof(SimStruct *);
14954 int_T m = addrlen/sizeof(int_T) + 1;
14955 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
14956 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
14957 pr = mxGetPr(prhs[1]);
14958 for (i = 0; i < m - 1; i++) {
14959 pr[i] = (double)intS[i];
14960 }
14961
14962 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
14963 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
14964 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
14965
14966 /* Reset port dimensions info functions because the S-function
14967 * and accelerator mex-files explicitly set their dimensions,
14968 * i.e., they are not dynamically sized. For this case, the
14969 * mex-file is responsible for the dimensions info memory
14970 * and Simulink should not free it. This is achieved by
14971 * setting the following two methods to NULL.
14972 */
14973 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
14974 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
14975
14976 /*
14977 * Setup function pointers and call mdlInitializeSizes via
14978 * simulink.c
14979 */
14980 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
14981 mxDestroyArray(plhs[0]);
14982 mxDestroyArray(prhs[0]);
14983 mxDestroyArray(prhs[1]);
14984 mxDestroyArray(prhs[2]);
14985 mxDestroyArray(prhs[3]);
14986 }
14987
14988#else
14989
14990 {
14991 Gain_sf(childS);
14992 sfcnInitializeSizes(childS);
14993 }
14994
14995#endif
14996
14997 sfcnInitializeSampleTimes(childS);
14998
14999 /* adjust sample time */
15000 ssSetSampleTime(childS, 0, 0.005);
15001 ssSetOffsetTime(childS, 0, 0.0);
15002 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];
15003
15004 /* set compiled values of dynamic vector attributes */
15005 ssSetNumNonsampledZCs(childS, 0);
15006
15007 /* Update connectivity flags for each port */
15008 _ssSetInputPortConnected(childS, 0, 1);
15009 _ssSetInputPortConnected(childS, 1, 1);
15010 _ssSetOutputPortConnected(childS, 0, 1);
15011 _ssSetOutputPortBeingMerged(childS, 0, 0);
15012
15013 /* Update the BufferDstPort flags for each input port */
15014 _ssSetInputPortBufferDstPort(childS, 0, -1);
15015 _ssSetInputPortBufferDstPort(childS, 1, -1);
15016 }
15017
15018 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S132>/Generated S-Function3 (IntegratorLimited_sf) */
15019 {
15020 SimStruct *childS = ssGetSFunction(rts, 56);
15021
15022 /* timing info */
15023 time_T *sfcnPeriod;
15024 time_T *sfcnOffset;
15025 int_T *sfcnTsMap;
15026 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
15027 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
15028 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
15029 ss_VALIDATE_MEMORY(rts,sfcnOffset);
15030 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
15031 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
15032 (void) memset((void*)sfcnPeriod, 0,
15033 sizeof(time_T)*1);
15034 (void) memset((void*)sfcnOffset, 0,
15035 sizeof(time_T)*1);
15036 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
15037 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
15038 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
15039
15040 /* Set up the mdlInfo pointer */
15041# ifdef USE_RTMODEL
15042
15043 {
15044 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
15045 struct _ssBlkInfo2));
15046 ss_VALIDATE_MEMORY(rts,blkInfo2);
15047 ssSetBlkInfo2Ptr(childS, blkInfo2);
15048 }
15049
15050 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
15051
15052# else
15053
15054 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
15055
15056# endif /* USE_RTMODEL */
15057
15058 /* Allocate memory of model methods 2 */
15059 {
15060 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
15061 malloc(sizeof(struct _ssSFcnModelMethods2));
15062 ss_VALIDATE_MEMORY(rts,methods2);
15063 ssSetModelMethods2(childS, methods2);
15064 }
15065
15066 /* Allocate memory of model methods 3 */
15067 {
15068 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
15069 malloc(sizeof(struct _ssSFcnModelMethods3));
15070 ss_VALIDATE_MEMORY(rts,methods3);
15071 ssSetModelMethods3(childS, methods3);
15072 }
15073
15074 /* Allocate memory for states auxilliary information */
15075 {
15076 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
15077 (sizeof(struct _ssStatesInfo2));
15078 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
15079 malloc(sizeof(ssPeriodicStatesInfo));
15080 ss_VALIDATE_MEMORY(rts,statesInfo2);
15081 ssSetStatesInfo2(childS, statesInfo2);
15082 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
15083 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
15084 }
15085
15086 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
15087 RegNumInputPorts);
15088 ssSetRegNumInputPortsFcnArg(childS,childS);
15089
15090 /* inputs */
15091 {
15092 struct _ssPortInputs *inputPortInfo =
15093 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
15094 ss_VALIDATE_MEMORY(rts,inputPortInfo);
15095 _ssSetNumInputPorts(childS, 7);
15096 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
15097
15098 /* port 0 */
15099 {
15100 real32_T const **sfcnUPtrs = (real32_T const **)
15101 malloc(1 * sizeof(real32_T *));
15102 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15103 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15104 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
15105 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
15106 _ssSetInputPortNumDimensions(childS, 0, 1);
15107 ssSetInputPortWidth(childS, 0, 1);
15108 }
15109
15110 /* port 1 */
15111 {
15112 int8_T const **sfcnUPtrs = (int8_T const **)
15113 malloc(1 * sizeof(int8_T *));
15114 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15115 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
15116 ssGetLocalBlockIO(rts))->DataTypeConversion3_d;
15117 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
15118 _ssSetInputPortNumDimensions(childS, 1, 1);
15119 ssSetInputPortWidth(childS, 1, 1);
15120 }
15121
15122 /* port 2 */
15123 {
15124 real32_T const **sfcnUPtrs = (real32_T const **)
15125 malloc(1 * sizeof(real32_T *));
15126 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15127 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15128 ssGetLocalBlockIO(rts))->Sum2_c;
15129 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
15130 _ssSetInputPortNumDimensions(childS, 2, 1);
15131 ssSetInputPortWidth(childS, 2, 1);
15132 }
15133
15134 /* port 3 */
15135 {
15136 real32_T const **sfcnUPtrs = (real32_T const **)
15137 malloc(1 * sizeof(real32_T *));
15138 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15139 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15140 ssGetLocalBlockIO(rts))->Sum2_c;
15141 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
15142 _ssSetInputPortNumDimensions(childS, 3, 1);
15143 ssSetInputPortWidth(childS, 3, 1);
15144 }
15145
15146 /* port 4 */
15147 {
15148 real32_T const **sfcnUPtrs = (real32_T const **)
15149 malloc(1 * sizeof(real32_T *));
15150 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15151 sfcnUPtrs[0] = (real32_T const *)
15152 &AFCS_MODEL1_ConstP.Constant29_Value;
15153 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
15154 _ssSetInputPortNumDimensions(childS, 4, 1);
15155 ssSetInputPortWidth(childS, 4, 1);
15156 }
15157
15158 /* port 5 */
15159 {
15160 real32_T const **sfcnUPtrs = (real32_T const **)
15161 malloc(1 * sizeof(real32_T *));
15162 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15163 sfcnUPtrs[0] = (real32_T const *)
15164 &AFCS_MODEL1_ConstP.Constant30_Value;
15165 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
15166 _ssSetInputPortNumDimensions(childS, 5, 1);
15167 ssSetInputPortWidth(childS, 5, 1);
15168 }
15169
15170 /* port 6 */
15171 {
15172 real32_T const **sfcnUPtrs = (real32_T const **)
15173 malloc(1 * sizeof(real32_T *));
15174 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15175 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15176 ssGetLocalBlockIO(rts))->Sum11;
15177 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
15178 _ssSetInputPortNumDimensions(childS, 6, 1);
15179 ssSetInputPortWidth(childS, 6, 1);
15180 }
15181 }
15182
15183 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
15184 RegNumOutputPorts);
15185 ssSetRegNumOutputPortsFcnArg(childS,childS);
15186
15187 /* outputs */
15188 {
15189 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
15190 calloc(1, sizeof(struct _ssPortOutputs));
15191 ss_VALIDATE_MEMORY(rts,outputPortInfo);
15192 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
15193 _ssSetNumOutputPorts(childS, 1);
15194
15195 /* port 0 */
15196 {
15197 _ssSetOutputPortNumDimensions(childS, 0, 1);
15198 ssSetOutputPortWidth(childS, 0, 1);
15199 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
15200 ssGetLocalBlockIO(rts))->GeneratedSFunction3));
15201 }
15202 }
15203
15204 /* path info */
15205 _ssSetModelName(childS, "IntegratorLimited_sf");
15206 _ssSetPath(childS,
15207 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/Integrator Limited/Generated S-Function3");
15208 if (ssGetRTModel(rts) == (NULL)) {
15209 _ssSetParentSS(childS, rts);
15210 _ssSetRootSS(childS, ssGetRootSS(rts));
15211 } else {
15212 ssSetRTModel(childS,ssGetRTModel(rts));
15213 _ssSetParentSS(childS, (NULL));
15214 _ssSetRootSS(childS, childS);
15215 }
15216
15217 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
15218
15219 /* work vectors */
15220 {
15221 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
15222 (4 * sizeof(struct _ssDWorkRecord));
15223 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
15224 calloc(4, sizeof(struct _ssDWorkAuxRecord));
15225 ss_VALIDATE_MEMORY(rts,dWorkRecord);
15226 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
15227 ssSetSFcnDWork(childS, dWorkRecord);
15228 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
15229 _ssSetNumDWork(childS, 4);
15230
15231 /* DWORK0 */
15232 ssSetDWorkWidth(childS, 0, 1);
15233 ssSetDWorkDataType(childS, 0,SS_SINGLE);
15234 ssSetDWorkComplexSignal(childS, 0, 0);
15235 ssSetDWorkUsedAsDState(childS, 0, 1);
15236 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 192))[0]);
15237
15238 /* DWORK1 */
15239 ssSetDWorkWidth(childS, 1, 1);
15240 ssSetDWorkDataType(childS, 1,SS_SINGLE);
15241 ssSetDWorkComplexSignal(childS, 1, 0);
15242 ssSetDWorkUsedAsDState(childS, 1, 1);
15243 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 193))[0]);
15244
15245 /* DWORK2 */
15246 ssSetDWorkWidth(childS, 2, 1);
15247 ssSetDWorkDataType(childS, 2,SS_INT8);
15248 ssSetDWorkComplexSignal(childS, 2, 0);
15249 ssSetDWorkUsedAsDState(childS, 2, 1);
15250 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 419))[0]);
15251
15252 /* DWORK3 */
15253 ssSetDWorkWidth(childS, 3, 1);
15254 ssSetDWorkDataType(childS, 3,SS_INT8);
15255 ssSetDWorkComplexSignal(childS, 3, 0);
15256 ssSetDWorkUsedAsDState(childS, 3, 1);
15257 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 420))[0]);
15258 }
15259
15260 (childS)->regDataType.arg1 = ((void *)(childS));
15261 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
15262 FcnSetErrorStatus);
15263 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
15264 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
15265 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
15266 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
15267
15268 /* registration */
15269#if defined(MATLAB_MEX_FILE)
15270
15271 {
15272 int_T i;
15273 mxArray *plhs[1];
15274 mxArray *prhs[4];
15275 double *pr;
15276 volatile int_T *intS = (int_T *)&childS;
15277 int_T addrlen = sizeof(SimStruct *);
15278 int_T m = addrlen/sizeof(int_T) + 1;
15279 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
15280 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
15281 pr = mxGetPr(prhs[1]);
15282 for (i = 0; i < m - 1; i++) {
15283 pr[i] = (double)intS[i];
15284 }
15285
15286 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
15287 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
15288 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
15289
15290 /* Reset port dimensions info functions because the S-function
15291 * and accelerator mex-files explicitly set their dimensions,
15292 * i.e., they are not dynamically sized. For this case, the
15293 * mex-file is responsible for the dimensions info memory
15294 * and Simulink should not free it. This is achieved by
15295 * setting the following two methods to NULL.
15296 */
15297 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
15298 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
15299
15300 /*
15301 * Setup function pointers and call mdlInitializeSizes via
15302 * simulink.c
15303 */
15304 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
15305 mxDestroyArray(plhs[0]);
15306 mxDestroyArray(prhs[0]);
15307 mxDestroyArray(prhs[1]);
15308 mxDestroyArray(prhs[2]);
15309 mxDestroyArray(prhs[3]);
15310 }
15311
15312#else
15313
15314 {
15315 IntegratorLimited_sf(childS);
15316 sfcnInitializeSizes(childS);
15317 }
15318
15319#endif
15320
15321 sfcnInitializeSampleTimes(childS);
15322
15323 /* adjust sample time */
15324 ssSetSampleTime(childS, 0, 0.0);
15325 ssSetOffsetTime(childS, 0, 0.0);
15326 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
15327
15328 /* set compiled values of dynamic vector attributes */
15329 ssSetNumNonsampledZCs(childS, 0);
15330
15331 /* Update connectivity flags for each port */
15332 _ssSetInputPortConnected(childS, 0, 1);
15333 _ssSetInputPortConnected(childS, 1, 1);
15334 _ssSetInputPortConnected(childS, 2, 1);
15335 _ssSetInputPortConnected(childS, 3, 1);
15336 _ssSetInputPortConnected(childS, 4, 1);
15337 _ssSetInputPortConnected(childS, 5, 1);
15338 _ssSetInputPortConnected(childS, 6, 1);
15339 _ssSetOutputPortConnected(childS, 0, 1);
15340 _ssSetOutputPortBeingMerged(childS, 0, 0);
15341
15342 /* Update the BufferDstPort flags for each input port */
15343 _ssSetInputPortBufferDstPort(childS, 0, -1);
15344 _ssSetInputPortBufferDstPort(childS, 1, -1);
15345 _ssSetInputPortBufferDstPort(childS, 2, -1);
15346 _ssSetInputPortBufferDstPort(childS, 3, -1);
15347 _ssSetInputPortBufferDstPort(childS, 4, -1);
15348 _ssSetInputPortBufferDstPort(childS, 5, -1);
15349 _ssSetInputPortBufferDstPort(childS, 6, -1);
15350 }
15351
15352 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S133>/Generated S-Function2 (LeadLagFilter_sf) */
15353 {
15354 SimStruct *childS = ssGetSFunction(rts, 57);
15355
15356 /* timing info */
15357 time_T *sfcnPeriod;
15358 time_T *sfcnOffset;
15359 int_T *sfcnTsMap;
15360 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
15361 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
15362 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
15363 ss_VALIDATE_MEMORY(rts,sfcnOffset);
15364 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
15365 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
15366 (void) memset((void*)sfcnPeriod, 0,
15367 sizeof(time_T)*1);
15368 (void) memset((void*)sfcnOffset, 0,
15369 sizeof(time_T)*1);
15370 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
15371 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
15372 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
15373
15374 /* Set up the mdlInfo pointer */
15375# ifdef USE_RTMODEL
15376
15377 {
15378 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
15379 struct _ssBlkInfo2));
15380 ss_VALIDATE_MEMORY(rts,blkInfo2);
15381 ssSetBlkInfo2Ptr(childS, blkInfo2);
15382 }
15383
15384 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
15385
15386# else
15387
15388 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
15389
15390# endif /* USE_RTMODEL */
15391
15392 /* Allocate memory of model methods 2 */
15393 {
15394 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
15395 malloc(sizeof(struct _ssSFcnModelMethods2));
15396 ss_VALIDATE_MEMORY(rts,methods2);
15397 ssSetModelMethods2(childS, methods2);
15398 }
15399
15400 /* Allocate memory of model methods 3 */
15401 {
15402 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
15403 malloc(sizeof(struct _ssSFcnModelMethods3));
15404 ss_VALIDATE_MEMORY(rts,methods3);
15405 ssSetModelMethods3(childS, methods3);
15406 }
15407
15408 /* Allocate memory for states auxilliary information */
15409 {
15410 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
15411 (sizeof(struct _ssStatesInfo2));
15412 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
15413 malloc(sizeof(ssPeriodicStatesInfo));
15414 ss_VALIDATE_MEMORY(rts,statesInfo2);
15415 ssSetStatesInfo2(childS, statesInfo2);
15416 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
15417 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
15418 }
15419
15420 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
15421 RegNumInputPorts);
15422 ssSetRegNumInputPortsFcnArg(childS,childS);
15423
15424 /* inputs */
15425 {
15426 struct _ssPortInputs *inputPortInfo =
15427 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
15428 ss_VALIDATE_MEMORY(rts,inputPortInfo);
15429 _ssSetNumInputPorts(childS, 7);
15430 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
15431
15432 /* port 0 */
15433 {
15434 real32_T const **sfcnUPtrs = (real32_T const **)
15435 malloc(1 * sizeof(real32_T *));
15436 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15437 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15438 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
15439 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
15440 _ssSetInputPortNumDimensions(childS, 0, 1);
15441 ssSetInputPortWidth(childS, 0, 1);
15442 }
15443
15444 /* port 1 */
15445 {
15446 int8_T const **sfcnUPtrs = (int8_T const **)
15447 malloc(1 * sizeof(int8_T *));
15448 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15449 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
15450 ssGetLocalBlockIO(rts))->DataTypeConversion3_d;
15451 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
15452 _ssSetInputPortNumDimensions(childS, 1, 1);
15453 ssSetInputPortWidth(childS, 1, 1);
15454 }
15455
15456 /* port 2 */
15457 {
15458 real32_T const **sfcnUPtrs = (real32_T const **)
15459 malloc(1 * sizeof(real32_T *));
15460 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15461 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
15462 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
15463 _ssSetInputPortNumDimensions(childS, 2, 1);
15464 ssSetInputPortWidth(childS, 2, 1);
15465 }
15466
15467 /* port 3 */
15468 {
15469 real32_T const **sfcnUPtrs = (real32_T const **)
15470 malloc(1 * sizeof(real32_T *));
15471 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15472 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
15473 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
15474 _ssSetInputPortNumDimensions(childS, 3, 1);
15475 ssSetInputPortWidth(childS, 3, 1);
15476 }
15477
15478 /* port 4 */
15479 {
15480 real32_T const **sfcnUPtrs = (real32_T const **)
15481 malloc(1 * sizeof(real32_T *));
15482 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15483 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15484 ssGetLocalBlockIO(rts))->Switch_bg;
15485 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
15486 _ssSetInputPortNumDimensions(childS, 4, 1);
15487 ssSetInputPortWidth(childS, 4, 1);
15488 }
15489
15490 /* port 5 */
15491 {
15492 real32_T const **sfcnUPtrs = (real32_T const **)
15493 malloc(1 * sizeof(real32_T *));
15494 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15495 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15496 ssGetLocalBlockIO(rts))->Switch_bg;
15497 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
15498 _ssSetInputPortNumDimensions(childS, 5, 1);
15499 ssSetInputPortWidth(childS, 5, 1);
15500 }
15501
15502 /* port 6 */
15503 {
15504 real32_T const **sfcnUPtrs = (real32_T const **)
15505 malloc(1 * sizeof(real32_T *));
15506 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15507 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15508 ssGetLocalBlockIO(rts))->Sum_c;
15509 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
15510 _ssSetInputPortNumDimensions(childS, 6, 1);
15511 ssSetInputPortWidth(childS, 6, 1);
15512 }
15513 }
15514
15515 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
15516 RegNumOutputPorts);
15517 ssSetRegNumOutputPortsFcnArg(childS,childS);
15518
15519 /* outputs */
15520 {
15521 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
15522 calloc(1, sizeof(struct _ssPortOutputs));
15523 ss_VALIDATE_MEMORY(rts,outputPortInfo);
15524 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
15525 _ssSetNumOutputPorts(childS, 1);
15526
15527 /* port 0 */
15528 {
15529 _ssSetOutputPortNumDimensions(childS, 0, 1);
15530 ssSetOutputPortWidth(childS, 0, 1);
15531 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
15532 ssGetLocalBlockIO(rts))->GeneratedSFunction2_f));
15533 }
15534 }
15535
15536 /* path info */
15537 _ssSetModelName(childS, "LeadLagFilter_sf");
15538 _ssSetPath(childS,
15539 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/Lead lag/Generated S-Function2");
15540 if (ssGetRTModel(rts) == (NULL)) {
15541 _ssSetParentSS(childS, rts);
15542 _ssSetRootSS(childS, ssGetRootSS(rts));
15543 } else {
15544 ssSetRTModel(childS,ssGetRTModel(rts));
15545 _ssSetParentSS(childS, (NULL));
15546 _ssSetRootSS(childS, childS);
15547 }
15548
15549 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
15550
15551 /* work vectors */
15552 {
15553 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
15554 (4 * sizeof(struct _ssDWorkRecord));
15555 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
15556 calloc(4, sizeof(struct _ssDWorkAuxRecord));
15557 ss_VALIDATE_MEMORY(rts,dWorkRecord);
15558 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
15559 ssSetSFcnDWork(childS, dWorkRecord);
15560 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
15561 _ssSetNumDWork(childS, 4);
15562
15563 /* DWORK0 */
15564 ssSetDWorkWidth(childS, 0, 1);
15565 ssSetDWorkDataType(childS, 0,SS_SINGLE);
15566 ssSetDWorkComplexSignal(childS, 0, 0);
15567 ssSetDWorkUsedAsDState(childS, 0, 1);
15568 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 194))[0]);
15569
15570 /* DWORK1 */
15571 ssSetDWorkWidth(childS, 1, 1);
15572 ssSetDWorkDataType(childS, 1,SS_SINGLE);
15573 ssSetDWorkComplexSignal(childS, 1, 0);
15574 ssSetDWorkUsedAsDState(childS, 1, 1);
15575 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 195))[0]);
15576
15577 /* DWORK2 */
15578 ssSetDWorkWidth(childS, 2, 1);
15579 ssSetDWorkDataType(childS, 2,SS_INT8);
15580 ssSetDWorkComplexSignal(childS, 2, 0);
15581 ssSetDWorkUsedAsDState(childS, 2, 1);
15582 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 421))[0]);
15583
15584 /* DWORK3 */
15585 ssSetDWorkWidth(childS, 3, 1);
15586 ssSetDWorkDataType(childS, 3,SS_INT8);
15587 ssSetDWorkComplexSignal(childS, 3, 0);
15588 ssSetDWorkUsedAsDState(childS, 3, 1);
15589 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 422))[0]);
15590 }
15591
15592 (childS)->regDataType.arg1 = ((void *)(childS));
15593 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
15594 FcnSetErrorStatus);
15595 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
15596 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
15597 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
15598 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
15599
15600 /* registration */
15601#if defined(MATLAB_MEX_FILE)
15602
15603 {
15604 int_T i;
15605 mxArray *plhs[1];
15606 mxArray *prhs[4];
15607 double *pr;
15608 volatile int_T *intS = (int_T *)&childS;
15609 int_T addrlen = sizeof(SimStruct *);
15610 int_T m = addrlen/sizeof(int_T) + 1;
15611 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
15612 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
15613 pr = mxGetPr(prhs[1]);
15614 for (i = 0; i < m - 1; i++) {
15615 pr[i] = (double)intS[i];
15616 }
15617
15618 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
15619 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
15620 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
15621
15622 /* Reset port dimensions info functions because the S-function
15623 * and accelerator mex-files explicitly set their dimensions,
15624 * i.e., they are not dynamically sized. For this case, the
15625 * mex-file is responsible for the dimensions info memory
15626 * and Simulink should not free it. This is achieved by
15627 * setting the following two methods to NULL.
15628 */
15629 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
15630 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
15631
15632 /*
15633 * Setup function pointers and call mdlInitializeSizes via
15634 * simulink.c
15635 */
15636 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
15637 mxDestroyArray(plhs[0]);
15638 mxDestroyArray(prhs[0]);
15639 mxDestroyArray(prhs[1]);
15640 mxDestroyArray(prhs[2]);
15641 mxDestroyArray(prhs[3]);
15642 }
15643
15644#else
15645
15646 {
15647 LeadLagFilter_sf(childS);
15648 sfcnInitializeSizes(childS);
15649 }
15650
15651#endif
15652
15653 sfcnInitializeSampleTimes(childS);
15654
15655 /* adjust sample time */
15656 ssSetSampleTime(childS, 0, 0.0);
15657 ssSetOffsetTime(childS, 0, 0.0);
15658 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
15659
15660 /* set compiled values of dynamic vector attributes */
15661 ssSetNumNonsampledZCs(childS, 0);
15662
15663 /* Update connectivity flags for each port */
15664 _ssSetInputPortConnected(childS, 0, 1);
15665 _ssSetInputPortConnected(childS, 1, 1);
15666 _ssSetInputPortConnected(childS, 2, 1);
15667 _ssSetInputPortConnected(childS, 3, 1);
15668 _ssSetInputPortConnected(childS, 4, 1);
15669 _ssSetInputPortConnected(childS, 5, 1);
15670 _ssSetInputPortConnected(childS, 6, 1);
15671 _ssSetOutputPortConnected(childS, 0, 1);
15672 _ssSetOutputPortBeingMerged(childS, 0, 0);
15673
15674 /* Update the BufferDstPort flags for each input port */
15675 _ssSetInputPortBufferDstPort(childS, 0, -1);
15676 _ssSetInputPortBufferDstPort(childS, 1, -1);
15677 _ssSetInputPortBufferDstPort(childS, 2, -1);
15678 _ssSetInputPortBufferDstPort(childS, 3, -1);
15679 _ssSetInputPortBufferDstPort(childS, 4, -1);
15680 _ssSetInputPortBufferDstPort(childS, 5, -1);
15681 _ssSetInputPortBufferDstPort(childS, 6, -1);
15682 }
15683
15684 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S131>/Generated S-Function4 (LagFilter_sf) */
15685 {
15686 SimStruct *childS = ssGetSFunction(rts, 58);
15687
15688 /* timing info */
15689 time_T *sfcnPeriod;
15690 time_T *sfcnOffset;
15691 int_T *sfcnTsMap;
15692 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
15693 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
15694 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
15695 ss_VALIDATE_MEMORY(rts,sfcnOffset);
15696 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
15697 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
15698 (void) memset((void*)sfcnPeriod, 0,
15699 sizeof(time_T)*1);
15700 (void) memset((void*)sfcnOffset, 0,
15701 sizeof(time_T)*1);
15702 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
15703 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
15704 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
15705
15706 /* Set up the mdlInfo pointer */
15707# ifdef USE_RTMODEL
15708
15709 {
15710 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
15711 struct _ssBlkInfo2));
15712 ss_VALIDATE_MEMORY(rts,blkInfo2);
15713 ssSetBlkInfo2Ptr(childS, blkInfo2);
15714 }
15715
15716 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
15717
15718# else
15719
15720 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
15721
15722# endif /* USE_RTMODEL */
15723
15724 /* Allocate memory of model methods 2 */
15725 {
15726 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
15727 malloc(sizeof(struct _ssSFcnModelMethods2));
15728 ss_VALIDATE_MEMORY(rts,methods2);
15729 ssSetModelMethods2(childS, methods2);
15730 }
15731
15732 /* Allocate memory of model methods 3 */
15733 {
15734 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
15735 malloc(sizeof(struct _ssSFcnModelMethods3));
15736 ss_VALIDATE_MEMORY(rts,methods3);
15737 ssSetModelMethods3(childS, methods3);
15738 }
15739
15740 /* Allocate memory for states auxilliary information */
15741 {
15742 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
15743 (sizeof(struct _ssStatesInfo2));
15744 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
15745 malloc(sizeof(ssPeriodicStatesInfo));
15746 ss_VALIDATE_MEMORY(rts,statesInfo2);
15747 ssSetStatesInfo2(childS, statesInfo2);
15748 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
15749 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
15750 }
15751
15752 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
15753 RegNumInputPorts);
15754 ssSetRegNumInputPortsFcnArg(childS,childS);
15755
15756 /* inputs */
15757 {
15758 struct _ssPortInputs *inputPortInfo =
15759 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
15760 ss_VALIDATE_MEMORY(rts,inputPortInfo);
15761 _ssSetNumInputPorts(childS, 6);
15762 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
15763
15764 /* port 0 */
15765 {
15766 real32_T const **sfcnUPtrs = (real32_T const **)
15767 malloc(1 * sizeof(real32_T *));
15768 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15769 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15770 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
15771 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
15772 _ssSetInputPortNumDimensions(childS, 0, 1);
15773 ssSetInputPortWidth(childS, 0, 1);
15774 }
15775
15776 /* port 1 */
15777 {
15778 int8_T const **sfcnUPtrs = (int8_T const **)
15779 malloc(1 * sizeof(int8_T *));
15780 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15781 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
15782 ssGetLocalBlockIO(rts))->DataTypeConversion3_d;
15783 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
15784 _ssSetInputPortNumDimensions(childS, 1, 1);
15785 ssSetInputPortWidth(childS, 1, 1);
15786 }
15787
15788 /* port 2 */
15789 {
15790 real32_T const **sfcnUPtrs = (real32_T const **)
15791 malloc(1 * sizeof(real32_T *));
15792 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15793 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
15794 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
15795 _ssSetInputPortNumDimensions(childS, 2, 1);
15796 ssSetInputPortWidth(childS, 2, 1);
15797 }
15798
15799 /* port 3 */
15800 {
15801 real32_T const **sfcnUPtrs = (real32_T const **)
15802 malloc(1 * sizeof(real32_T *));
15803 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15804 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15805 ssGetLocalBlockIO(rts))->Switch_bg;
15806 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
15807 _ssSetInputPortNumDimensions(childS, 3, 1);
15808 ssSetInputPortWidth(childS, 3, 1);
15809 }
15810
15811 /* port 4 */
15812 {
15813 real32_T const **sfcnUPtrs = (real32_T const **)
15814 malloc(1 * sizeof(real32_T *));
15815 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15816 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15817 ssGetLocalBlockIO(rts))->Switch_bg;
15818 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
15819 _ssSetInputPortNumDimensions(childS, 4, 1);
15820 ssSetInputPortWidth(childS, 4, 1);
15821 }
15822
15823 /* port 5 */
15824 {
15825 real32_T const **sfcnUPtrs = (real32_T const **)
15826 malloc(1 * sizeof(real32_T *));
15827 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
15828 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
15829 ssGetLocalBlockIO(rts))->GeneratedSFunction2_f;
15830 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
15831 _ssSetInputPortNumDimensions(childS, 5, 1);
15832 ssSetInputPortWidth(childS, 5, 1);
15833 }
15834 }
15835
15836 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
15837 RegNumOutputPorts);
15838 ssSetRegNumOutputPortsFcnArg(childS,childS);
15839
15840 /* outputs */
15841 {
15842 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
15843 calloc(1, sizeof(struct _ssPortOutputs));
15844 ss_VALIDATE_MEMORY(rts,outputPortInfo);
15845 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
15846 _ssSetNumOutputPorts(childS, 1);
15847
15848 /* port 0 */
15849 {
15850 _ssSetOutputPortNumDimensions(childS, 0, 1);
15851 ssSetOutputPortWidth(childS, 0, 1);
15852 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
15853 ssGetLocalBlockIO(rts))->GeneratedSFunction4_m));
15854 }
15855 }
15856
15857 /* path info */
15858 _ssSetModelName(childS, "LagFilter_sf");
15859 _ssSetPath(childS,
15860 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PhiLControl/ lag filter/Generated S-Function4");
15861 if (ssGetRTModel(rts) == (NULL)) {
15862 _ssSetParentSS(childS, rts);
15863 _ssSetRootSS(childS, ssGetRootSS(rts));
15864 } else {
15865 ssSetRTModel(childS,ssGetRTModel(rts));
15866 _ssSetParentSS(childS, (NULL));
15867 _ssSetRootSS(childS, childS);
15868 }
15869
15870 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
15871
15872 /* work vectors */
15873 {
15874 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
15875 (4 * sizeof(struct _ssDWorkRecord));
15876 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
15877 calloc(4, sizeof(struct _ssDWorkAuxRecord));
15878 ss_VALIDATE_MEMORY(rts,dWorkRecord);
15879 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
15880 ssSetSFcnDWork(childS, dWorkRecord);
15881 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
15882 _ssSetNumDWork(childS, 4);
15883
15884 /* DWORK0 */
15885 ssSetDWorkWidth(childS, 0, 1);
15886 ssSetDWorkDataType(childS, 0,SS_SINGLE);
15887 ssSetDWorkComplexSignal(childS, 0, 0);
15888 ssSetDWorkUsedAsDState(childS, 0, 1);
15889 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 196))[0]);
15890
15891 /* DWORK1 */
15892 ssSetDWorkWidth(childS, 1, 1);
15893 ssSetDWorkDataType(childS, 1,SS_SINGLE);
15894 ssSetDWorkComplexSignal(childS, 1, 0);
15895 ssSetDWorkUsedAsDState(childS, 1, 1);
15896 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 197))[0]);
15897
15898 /* DWORK2 */
15899 ssSetDWorkWidth(childS, 2, 1);
15900 ssSetDWorkDataType(childS, 2,SS_INT8);
15901 ssSetDWorkComplexSignal(childS, 2, 0);
15902 ssSetDWorkUsedAsDState(childS, 2, 1);
15903 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 423))[0]);
15904
15905 /* DWORK3 */
15906 ssSetDWorkWidth(childS, 3, 1);
15907 ssSetDWorkDataType(childS, 3,SS_INT8);
15908 ssSetDWorkComplexSignal(childS, 3, 0);
15909 ssSetDWorkUsedAsDState(childS, 3, 1);
15910 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 424))[0]);
15911 }
15912
15913 (childS)->regDataType.arg1 = ((void *)(childS));
15914 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
15915 FcnSetErrorStatus);
15916 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
15917 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
15918 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
15919 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
15920
15921 /* registration */
15922#if defined(MATLAB_MEX_FILE)
15923
15924 {
15925 int_T i;
15926 mxArray *plhs[1];
15927 mxArray *prhs[4];
15928 double *pr;
15929 volatile int_T *intS = (int_T *)&childS;
15930 int_T addrlen = sizeof(SimStruct *);
15931 int_T m = addrlen/sizeof(int_T) + 1;
15932 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
15933 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
15934 pr = mxGetPr(prhs[1]);
15935 for (i = 0; i < m - 1; i++) {
15936 pr[i] = (double)intS[i];
15937 }
15938
15939 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
15940 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
15941 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
15942
15943 /* Reset port dimensions info functions because the S-function
15944 * and accelerator mex-files explicitly set their dimensions,
15945 * i.e., they are not dynamically sized. For this case, the
15946 * mex-file is responsible for the dimensions info memory
15947 * and Simulink should not free it. This is achieved by
15948 * setting the following two methods to NULL.
15949 */
15950 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
15951 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
15952
15953 /*
15954 * Setup function pointers and call mdlInitializeSizes via
15955 * simulink.c
15956 */
15957 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
15958 mxDestroyArray(plhs[0]);
15959 mxDestroyArray(prhs[0]);
15960 mxDestroyArray(prhs[1]);
15961 mxDestroyArray(prhs[2]);
15962 mxDestroyArray(prhs[3]);
15963 }
15964
15965#else
15966
15967 {
15968 LagFilter_sf(childS);
15969 sfcnInitializeSizes(childS);
15970 }
15971
15972#endif
15973
15974 sfcnInitializeSampleTimes(childS);
15975
15976 /* adjust sample time */
15977 ssSetSampleTime(childS, 0, 0.0);
15978 ssSetOffsetTime(childS, 0, 0.0);
15979 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
15980
15981 /* set compiled values of dynamic vector attributes */
15982 ssSetNumNonsampledZCs(childS, 0);
15983
15984 /* Update connectivity flags for each port */
15985 _ssSetInputPortConnected(childS, 0, 1);
15986 _ssSetInputPortConnected(childS, 1, 1);
15987 _ssSetInputPortConnected(childS, 2, 1);
15988 _ssSetInputPortConnected(childS, 3, 1);
15989 _ssSetInputPortConnected(childS, 4, 1);
15990 _ssSetInputPortConnected(childS, 5, 1);
15991 _ssSetOutputPortConnected(childS, 0, 1);
15992 _ssSetOutputPortBeingMerged(childS, 0, 0);
15993
15994 /* Update the BufferDstPort flags for each input port */
15995 _ssSetInputPortBufferDstPort(childS, 0, -1);
15996 _ssSetInputPortBufferDstPort(childS, 1, -1);
15997 _ssSetInputPortBufferDstPort(childS, 2, -1);
15998 _ssSetInputPortBufferDstPort(childS, 3, -1);
15999 _ssSetInputPortBufferDstPort(childS, 4, -1);
16000 _ssSetInputPortBufferDstPort(childS, 5, -1);
16001 }
16002
16003 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S155>/Generated S-Function1 (SaturationLimiter_sf) */
16004 {
16005 SimStruct *childS = ssGetSFunction(rts, 59);
16006
16007 /* timing info */
16008 time_T *sfcnPeriod;
16009 time_T *sfcnOffset;
16010 int_T *sfcnTsMap;
16011 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
16012 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
16013 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
16014 ss_VALIDATE_MEMORY(rts,sfcnOffset);
16015 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
16016 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
16017 (void) memset((void*)sfcnPeriod, 0,
16018 sizeof(time_T)*1);
16019 (void) memset((void*)sfcnOffset, 0,
16020 sizeof(time_T)*1);
16021 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
16022 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
16023 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
16024
16025 /* Set up the mdlInfo pointer */
16026# ifdef USE_RTMODEL
16027
16028 {
16029 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
16030 struct _ssBlkInfo2));
16031 ss_VALIDATE_MEMORY(rts,blkInfo2);
16032 ssSetBlkInfo2Ptr(childS, blkInfo2);
16033 }
16034
16035 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
16036
16037# else
16038
16039 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
16040
16041# endif /* USE_RTMODEL */
16042
16043 /* Allocate memory of model methods 2 */
16044 {
16045 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
16046 malloc(sizeof(struct _ssSFcnModelMethods2));
16047 ss_VALIDATE_MEMORY(rts,methods2);
16048 ssSetModelMethods2(childS, methods2);
16049 }
16050
16051 /* Allocate memory of model methods 3 */
16052 {
16053 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
16054 malloc(sizeof(struct _ssSFcnModelMethods3));
16055 ss_VALIDATE_MEMORY(rts,methods3);
16056 ssSetModelMethods3(childS, methods3);
16057 }
16058
16059 /* Allocate memory for states auxilliary information */
16060 {
16061 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
16062 (sizeof(struct _ssStatesInfo2));
16063 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
16064 malloc(sizeof(ssPeriodicStatesInfo));
16065 ss_VALIDATE_MEMORY(rts,statesInfo2);
16066 ssSetStatesInfo2(childS, statesInfo2);
16067 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
16068 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
16069 }
16070
16071 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
16072 RegNumInputPorts);
16073 ssSetRegNumInputPortsFcnArg(childS,childS);
16074
16075 /* inputs */
16076 {
16077 struct _ssPortInputs *inputPortInfo =
16078 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
16079 ss_VALIDATE_MEMORY(rts,inputPortInfo);
16080 _ssSetNumInputPorts(childS, 3);
16081 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
16082
16083 /* port 0 */
16084 {
16085 real32_T const **sfcnUPtrs = (real32_T const **)
16086 malloc(1 * sizeof(real32_T *));
16087 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16088 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
16089 ssGetLocalBlockIO(rts))->Divide_c;
16090 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
16091 _ssSetInputPortNumDimensions(childS, 0, 1);
16092 ssSetInputPortWidth(childS, 0, 1);
16093 }
16094
16095 /* port 1 */
16096 {
16097 real32_T const **sfcnUPtrs = (real32_T const **)
16098 malloc(1 * sizeof(real32_T *));
16099 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16100 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
16101 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
16102 _ssSetInputPortNumDimensions(childS, 1, 1);
16103 ssSetInputPortWidth(childS, 1, 1);
16104 }
16105
16106 /* port 2 */
16107 {
16108 real32_T const **sfcnUPtrs = (real32_T const **)
16109 malloc(1 * sizeof(real32_T *));
16110 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16111 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;
16112 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
16113 _ssSetInputPortNumDimensions(childS, 2, 1);
16114 ssSetInputPortWidth(childS, 2, 1);
16115 }
16116 }
16117
16118 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
16119 RegNumOutputPorts);
16120 ssSetRegNumOutputPortsFcnArg(childS,childS);
16121
16122 /* outputs */
16123 {
16124 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
16125 calloc(1, sizeof(struct _ssPortOutputs));
16126 ss_VALIDATE_MEMORY(rts,outputPortInfo);
16127 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
16128 _ssSetNumOutputPorts(childS, 1);
16129
16130 /* port 0 */
16131 {
16132 _ssSetOutputPortNumDimensions(childS, 0, 1);
16133 ssSetOutputPortWidth(childS, 0, 1);
16134 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
16135 ssGetLocalBlockIO(rts))->GeneratedSFunction1_o));
16136 }
16137 }
16138
16139 /* path info */
16140 _ssSetModelName(childS, "SaturationLimiter_sf");
16141 _ssSetPath(childS,
16142 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Saturation Limiter2/Generated S-Function1");
16143 if (ssGetRTModel(rts) == (NULL)) {
16144 _ssSetParentSS(childS, rts);
16145 _ssSetRootSS(childS, ssGetRootSS(rts));
16146 } else {
16147 ssSetRTModel(childS,ssGetRTModel(rts));
16148 _ssSetParentSS(childS, (NULL));
16149 _ssSetRootSS(childS, childS);
16150 }
16151
16152 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
16153 (childS)->regDataType.arg1 = ((void *)(childS));
16154 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
16155 FcnSetErrorStatus);
16156 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
16157 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
16158 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
16159 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
16160
16161 /* registration */
16162#if defined(MATLAB_MEX_FILE)
16163
16164 {
16165 int_T i;
16166 mxArray *plhs[1];
16167 mxArray *prhs[4];
16168 double *pr;
16169 volatile int_T *intS = (int_T *)&childS;
16170 int_T addrlen = sizeof(SimStruct *);
16171 int_T m = addrlen/sizeof(int_T) + 1;
16172 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
16173 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
16174 pr = mxGetPr(prhs[1]);
16175 for (i = 0; i < m - 1; i++) {
16176 pr[i] = (double)intS[i];
16177 }
16178
16179 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
16180 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
16181 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
16182
16183 /* Reset port dimensions info functions because the S-function
16184 * and accelerator mex-files explicitly set their dimensions,
16185 * i.e., they are not dynamically sized. For this case, the
16186 * mex-file is responsible for the dimensions info memory
16187 * and Simulink should not free it. This is achieved by
16188 * setting the following two methods to NULL.
16189 */
16190 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
16191 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
16192
16193 /*
16194 * Setup function pointers and call mdlInitializeSizes via
16195 * simulink.c
16196 */
16197 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
16198 mxDestroyArray(plhs[0]);
16199 mxDestroyArray(prhs[0]);
16200 mxDestroyArray(prhs[1]);
16201 mxDestroyArray(prhs[2]);
16202 mxDestroyArray(prhs[3]);
16203 }
16204
16205#else
16206
16207 {
16208 SaturationLimiter_sf(childS);
16209 sfcnInitializeSizes(childS);
16210 }
16211
16212#endif
16213
16214 sfcnInitializeSampleTimes(childS);
16215
16216 /* adjust sample time */
16217 ssSetSampleTime(childS, 0, 0.005);
16218 ssSetOffsetTime(childS, 0, 0.0);
16219 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];
16220
16221 /* set compiled values of dynamic vector attributes */
16222 ssSetNumNonsampledZCs(childS, 0);
16223
16224 /* Update connectivity flags for each port */
16225 _ssSetInputPortConnected(childS, 0, 1);
16226 _ssSetInputPortConnected(childS, 1, 1);
16227 _ssSetInputPortConnected(childS, 2, 1);
16228 _ssSetOutputPortConnected(childS, 0, 1);
16229 _ssSetOutputPortBeingMerged(childS, 0, 0);
16230
16231 /* Update the BufferDstPort flags for each input port */
16232 _ssSetInputPortBufferDstPort(childS, 0, -1);
16233 _ssSetInputPortBufferDstPort(childS, 1, -1);
16234 _ssSetInputPortBufferDstPort(childS, 2, -1);
16235 }
16236
16237 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S128>/Generated S-Function6 (Res180_sf) */
16238 {
16239 SimStruct *childS = ssGetSFunction(rts, 60);
16240
16241 /* timing info */
16242 time_T *sfcnPeriod;
16243 time_T *sfcnOffset;
16244 int_T *sfcnTsMap;
16245 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
16246 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
16247 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
16248 ss_VALIDATE_MEMORY(rts,sfcnOffset);
16249 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
16250 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
16251 (void) memset((void*)sfcnPeriod, 0,
16252 sizeof(time_T)*1);
16253 (void) memset((void*)sfcnOffset, 0,
16254 sizeof(time_T)*1);
16255 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
16256 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
16257 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
16258
16259 /* Set up the mdlInfo pointer */
16260# ifdef USE_RTMODEL
16261
16262 {
16263 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
16264 struct _ssBlkInfo2));
16265 ss_VALIDATE_MEMORY(rts,blkInfo2);
16266 ssSetBlkInfo2Ptr(childS, blkInfo2);
16267 }
16268
16269 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
16270
16271# else
16272
16273 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
16274
16275# endif /* USE_RTMODEL */
16276
16277 /* Allocate memory of model methods 2 */
16278 {
16279 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
16280 malloc(sizeof(struct _ssSFcnModelMethods2));
16281 ss_VALIDATE_MEMORY(rts,methods2);
16282 ssSetModelMethods2(childS, methods2);
16283 }
16284
16285 /* Allocate memory of model methods 3 */
16286 {
16287 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
16288 malloc(sizeof(struct _ssSFcnModelMethods3));
16289 ss_VALIDATE_MEMORY(rts,methods3);
16290 ssSetModelMethods3(childS, methods3);
16291 }
16292
16293 /* Allocate memory for states auxilliary information */
16294 {
16295 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
16296 (sizeof(struct _ssStatesInfo2));
16297 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
16298 malloc(sizeof(ssPeriodicStatesInfo));
16299 ss_VALIDATE_MEMORY(rts,statesInfo2);
16300 ssSetStatesInfo2(childS, statesInfo2);
16301 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
16302 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
16303 }
16304
16305 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
16306 RegNumInputPorts);
16307 ssSetRegNumInputPortsFcnArg(childS,childS);
16308
16309 /* inputs */
16310 {
16311 struct _ssPortInputs *inputPortInfo =
16312 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
16313 ss_VALIDATE_MEMORY(rts,inputPortInfo);
16314 _ssSetNumInputPorts(childS, 1);
16315 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
16316
16317 /* port 0 */
16318 {
16319 real32_T const **sfcnUPtrs = (real32_T const **)
16320 malloc(1 * sizeof(real32_T *));
16321 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16322 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
16323 ssGetLocalBlockIO(rts))->Sum3_g;
16324 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
16325 _ssSetInputPortNumDimensions(childS, 0, 1);
16326 ssSetInputPortWidth(childS, 0, 1);
16327 }
16328 }
16329
16330 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
16331 RegNumOutputPorts);
16332 ssSetRegNumOutputPortsFcnArg(childS,childS);
16333
16334 /* outputs */
16335 {
16336 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
16337 calloc(1, sizeof(struct _ssPortOutputs));
16338 ss_VALIDATE_MEMORY(rts,outputPortInfo);
16339 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
16340 _ssSetNumOutputPorts(childS, 1);
16341
16342 /* port 0 */
16343 {
16344 _ssSetOutputPortNumDimensions(childS, 0, 1);
16345 ssSetOutputPortWidth(childS, 0, 1);
16346 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
16347 ssGetLocalBlockIO(rts))->GeneratedSFunction6_g));
16348 }
16349 }
16350
16351 /* path info */
16352 _ssSetModelName(childS, "Res180_sf");
16353 _ssSetPath(childS,
16354 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Generated S-Function6");
16355 if (ssGetRTModel(rts) == (NULL)) {
16356 _ssSetParentSS(childS, rts);
16357 _ssSetRootSS(childS, ssGetRootSS(rts));
16358 } else {
16359 ssSetRTModel(childS,ssGetRTModel(rts));
16360 _ssSetParentSS(childS, (NULL));
16361 _ssSetRootSS(childS, childS);
16362 }
16363
16364 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
16365 (childS)->regDataType.arg1 = ((void *)(childS));
16366 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
16367 FcnSetErrorStatus);
16368 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
16369 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
16370 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
16371 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
16372
16373 /* registration */
16374#if defined(MATLAB_MEX_FILE)
16375
16376 {
16377 int_T i;
16378 mxArray *plhs[1];
16379 mxArray *prhs[4];
16380 double *pr;
16381 volatile int_T *intS = (int_T *)&childS;
16382 int_T addrlen = sizeof(SimStruct *);
16383 int_T m = addrlen/sizeof(int_T) + 1;
16384 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
16385 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
16386 pr = mxGetPr(prhs[1]);
16387 for (i = 0; i < m - 1; i++) {
16388 pr[i] = (double)intS[i];
16389 }
16390
16391 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
16392 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
16393 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
16394
16395 /* Reset port dimensions info functions because the S-function
16396 * and accelerator mex-files explicitly set their dimensions,
16397 * i.e., they are not dynamically sized. For this case, the
16398 * mex-file is responsible for the dimensions info memory
16399 * and Simulink should not free it. This is achieved by
16400 * setting the following two methods to NULL.
16401 */
16402 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
16403 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
16404
16405 /*
16406 * Setup function pointers and call mdlInitializeSizes via
16407 * simulink.c
16408 */
16409 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
16410 mxDestroyArray(plhs[0]);
16411 mxDestroyArray(prhs[0]);
16412 mxDestroyArray(prhs[1]);
16413 mxDestroyArray(prhs[2]);
16414 mxDestroyArray(prhs[3]);
16415 }
16416
16417#else
16418
16419 {
16420 Res180_sf(childS);
16421 sfcnInitializeSizes(childS);
16422 }
16423
16424#endif
16425
16426 sfcnInitializeSampleTimes(childS);
16427
16428 /* adjust sample time */
16429 ssSetSampleTime(childS, 0, 0.0);
16430 ssSetOffsetTime(childS, 0, 0.0);
16431 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
16432
16433 /* set compiled values of dynamic vector attributes */
16434 ssSetNumNonsampledZCs(childS, 0);
16435
16436 /* Update connectivity flags for each port */
16437 _ssSetInputPortConnected(childS, 0, 1);
16438 _ssSetOutputPortConnected(childS, 0, 1);
16439 _ssSetOutputPortBeingMerged(childS, 0, 0);
16440
16441 /* Update the BufferDstPort flags for each input port */
16442 _ssSetInputPortBufferDstPort(childS, 0, -1);
16443 }
16444
16445 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S154>/Generated S-Function1 (SaturationLimiter_sf) */
16446 {
16447 SimStruct *childS = ssGetSFunction(rts, 61);
16448
16449 /* timing info */
16450 time_T *sfcnPeriod;
16451 time_T *sfcnOffset;
16452 int_T *sfcnTsMap;
16453 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
16454 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
16455 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
16456 ss_VALIDATE_MEMORY(rts,sfcnOffset);
16457 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
16458 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
16459 (void) memset((void*)sfcnPeriod, 0,
16460 sizeof(time_T)*1);
16461 (void) memset((void*)sfcnOffset, 0,
16462 sizeof(time_T)*1);
16463 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
16464 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
16465 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
16466
16467 /* Set up the mdlInfo pointer */
16468# ifdef USE_RTMODEL
16469
16470 {
16471 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
16472 struct _ssBlkInfo2));
16473 ss_VALIDATE_MEMORY(rts,blkInfo2);
16474 ssSetBlkInfo2Ptr(childS, blkInfo2);
16475 }
16476
16477 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
16478
16479# else
16480
16481 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
16482
16483# endif /* USE_RTMODEL */
16484
16485 /* Allocate memory of model methods 2 */
16486 {
16487 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
16488 malloc(sizeof(struct _ssSFcnModelMethods2));
16489 ss_VALIDATE_MEMORY(rts,methods2);
16490 ssSetModelMethods2(childS, methods2);
16491 }
16492
16493 /* Allocate memory of model methods 3 */
16494 {
16495 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
16496 malloc(sizeof(struct _ssSFcnModelMethods3));
16497 ss_VALIDATE_MEMORY(rts,methods3);
16498 ssSetModelMethods3(childS, methods3);
16499 }
16500
16501 /* Allocate memory for states auxilliary information */
16502 {
16503 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
16504 (sizeof(struct _ssStatesInfo2));
16505 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
16506 malloc(sizeof(ssPeriodicStatesInfo));
16507 ss_VALIDATE_MEMORY(rts,statesInfo2);
16508 ssSetStatesInfo2(childS, statesInfo2);
16509 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
16510 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
16511 }
16512
16513 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
16514 RegNumInputPorts);
16515 ssSetRegNumInputPortsFcnArg(childS,childS);
16516
16517 /* inputs */
16518 {
16519 struct _ssPortInputs *inputPortInfo =
16520 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
16521 ss_VALIDATE_MEMORY(rts,inputPortInfo);
16522 _ssSetNumInputPorts(childS, 3);
16523 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
16524
16525 /* port 0 */
16526 {
16527 real32_T const **sfcnUPtrs = (real32_T const **)
16528 malloc(1 * sizeof(real32_T *));
16529 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16530 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
16531 ssGetLocalBlockIO(rts))->GeneratedSFunction6_g;
16532 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
16533 _ssSetInputPortNumDimensions(childS, 0, 1);
16534 ssSetInputPortWidth(childS, 0, 1);
16535 }
16536
16537 /* port 1 */
16538 {
16539 real32_T const **sfcnUPtrs = (real32_T const **)
16540 malloc(1 * sizeof(real32_T *));
16541 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16542 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;
16543 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
16544 _ssSetInputPortNumDimensions(childS, 1, 1);
16545 ssSetInputPortWidth(childS, 1, 1);
16546 }
16547
16548 /* port 2 */
16549 {
16550 real32_T const **sfcnUPtrs = (real32_T const **)
16551 malloc(1 * sizeof(real32_T *));
16552 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16553 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;
16554 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
16555 _ssSetInputPortNumDimensions(childS, 2, 1);
16556 ssSetInputPortWidth(childS, 2, 1);
16557 }
16558 }
16559
16560 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
16561 RegNumOutputPorts);
16562 ssSetRegNumOutputPortsFcnArg(childS,childS);
16563
16564 /* outputs */
16565 {
16566 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
16567 calloc(1, sizeof(struct _ssPortOutputs));
16568 ss_VALIDATE_MEMORY(rts,outputPortInfo);
16569 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
16570 _ssSetNumOutputPorts(childS, 1);
16571
16572 /* port 0 */
16573 {
16574 _ssSetOutputPortNumDimensions(childS, 0, 1);
16575 ssSetOutputPortWidth(childS, 0, 1);
16576 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
16577 ssGetLocalBlockIO(rts))->GeneratedSFunction1_m));
16578 }
16579 }
16580
16581 /* path info */
16582 _ssSetModelName(childS, "SaturationLimiter_sf");
16583 _ssSetPath(childS,
16584 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Saturation Limiter1/Generated S-Function1");
16585 if (ssGetRTModel(rts) == (NULL)) {
16586 _ssSetParentSS(childS, rts);
16587 _ssSetRootSS(childS, ssGetRootSS(rts));
16588 } else {
16589 ssSetRTModel(childS,ssGetRTModel(rts));
16590 _ssSetParentSS(childS, (NULL));
16591 _ssSetRootSS(childS, childS);
16592 }
16593
16594 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
16595 (childS)->regDataType.arg1 = ((void *)(childS));
16596 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
16597 FcnSetErrorStatus);
16598 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
16599 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
16600 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
16601 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
16602
16603 /* registration */
16604#if defined(MATLAB_MEX_FILE)
16605
16606 {
16607 int_T i;
16608 mxArray *plhs[1];
16609 mxArray *prhs[4];
16610 double *pr;
16611 volatile int_T *intS = (int_T *)&childS;
16612 int_T addrlen = sizeof(SimStruct *);
16613 int_T m = addrlen/sizeof(int_T) + 1;
16614 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
16615 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
16616 pr = mxGetPr(prhs[1]);
16617 for (i = 0; i < m - 1; i++) {
16618 pr[i] = (double)intS[i];
16619 }
16620
16621 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
16622 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
16623 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
16624
16625 /* Reset port dimensions info functions because the S-function
16626 * and accelerator mex-files explicitly set their dimensions,
16627 * i.e., they are not dynamically sized. For this case, the
16628 * mex-file is responsible for the dimensions info memory
16629 * and Simulink should not free it. This is achieved by
16630 * setting the following two methods to NULL.
16631 */
16632 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
16633 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
16634
16635 /*
16636 * Setup function pointers and call mdlInitializeSizes via
16637 * simulink.c
16638 */
16639 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
16640 mxDestroyArray(plhs[0]);
16641 mxDestroyArray(prhs[0]);
16642 mxDestroyArray(prhs[1]);
16643 mxDestroyArray(prhs[2]);
16644 mxDestroyArray(prhs[3]);
16645 }
16646
16647#else
16648
16649 {
16650 SaturationLimiter_sf(childS);
16651 sfcnInitializeSizes(childS);
16652 }
16653
16654#endif
16655
16656 sfcnInitializeSampleTimes(childS);
16657
16658 /* adjust sample time */
16659 ssSetSampleTime(childS, 0, 0.0);
16660 ssSetOffsetTime(childS, 0, 0.0);
16661 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
16662
16663 /* set compiled values of dynamic vector attributes */
16664 ssSetNumNonsampledZCs(childS, 0);
16665
16666 /* Update connectivity flags for each port */
16667 _ssSetInputPortConnected(childS, 0, 1);
16668 _ssSetInputPortConnected(childS, 1, 1);
16669 _ssSetInputPortConnected(childS, 2, 1);
16670 _ssSetOutputPortConnected(childS, 0, 1);
16671 _ssSetOutputPortBeingMerged(childS, 0, 0);
16672
16673 /* Update the BufferDstPort flags for each input port */
16674 _ssSetInputPortBufferDstPort(childS, 0, -1);
16675 _ssSetInputPortBufferDstPort(childS, 1, -1);
16676 _ssSetInputPortBufferDstPort(childS, 2, -1);
16677 }
16678
16679 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S158>/Generated S-Function (Gain_sf) */
16680 {
16681 SimStruct *childS = ssGetSFunction(rts, 62);
16682
16683 /* timing info */
16684 time_T *sfcnPeriod;
16685 time_T *sfcnOffset;
16686 int_T *sfcnTsMap;
16687 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
16688 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
16689 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
16690 ss_VALIDATE_MEMORY(rts,sfcnOffset);
16691 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
16692 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
16693 (void) memset((void*)sfcnPeriod, 0,
16694 sizeof(time_T)*1);
16695 (void) memset((void*)sfcnOffset, 0,
16696 sizeof(time_T)*1);
16697 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
16698 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
16699 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
16700
16701 /* Set up the mdlInfo pointer */
16702# ifdef USE_RTMODEL
16703
16704 {
16705 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
16706 struct _ssBlkInfo2));
16707 ss_VALIDATE_MEMORY(rts,blkInfo2);
16708 ssSetBlkInfo2Ptr(childS, blkInfo2);
16709 }
16710
16711 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
16712
16713# else
16714
16715 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
16716
16717# endif /* USE_RTMODEL */
16718
16719 /* Allocate memory of model methods 2 */
16720 {
16721 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
16722 malloc(sizeof(struct _ssSFcnModelMethods2));
16723 ss_VALIDATE_MEMORY(rts,methods2);
16724 ssSetModelMethods2(childS, methods2);
16725 }
16726
16727 /* Allocate memory of model methods 3 */
16728 {
16729 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
16730 malloc(sizeof(struct _ssSFcnModelMethods3));
16731 ss_VALIDATE_MEMORY(rts,methods3);
16732 ssSetModelMethods3(childS, methods3);
16733 }
16734
16735 /* Allocate memory for states auxilliary information */
16736 {
16737 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
16738 (sizeof(struct _ssStatesInfo2));
16739 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
16740 malloc(sizeof(ssPeriodicStatesInfo));
16741 ss_VALIDATE_MEMORY(rts,statesInfo2);
16742 ssSetStatesInfo2(childS, statesInfo2);
16743 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
16744 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
16745 }
16746
16747 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
16748 RegNumInputPorts);
16749 ssSetRegNumInputPortsFcnArg(childS,childS);
16750
16751 /* inputs */
16752 {
16753 struct _ssPortInputs *inputPortInfo =
16754 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
16755 ss_VALIDATE_MEMORY(rts,inputPortInfo);
16756 _ssSetNumInputPorts(childS, 2);
16757 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
16758
16759 /* port 0 */
16760 {
16761 real32_T const **sfcnUPtrs = (real32_T const **)
16762 malloc(1 * sizeof(real32_T *));
16763 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16764 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
16765 ssGetLocalBlockIO(rts))->GeneratedSFunction1_m;
16766 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
16767 _ssSetInputPortNumDimensions(childS, 0, 1);
16768 ssSetInputPortWidth(childS, 0, 1);
16769 }
16770
16771 /* port 1 */
16772 {
16773 real32_T const **sfcnUPtrs = (real32_T const **)
16774 malloc(1 * sizeof(real32_T *));
16775 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16776 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled122;
16777 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
16778 _ssSetInputPortNumDimensions(childS, 1, 1);
16779 ssSetInputPortWidth(childS, 1, 1);
16780 }
16781 }
16782
16783 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
16784 RegNumOutputPorts);
16785 ssSetRegNumOutputPortsFcnArg(childS,childS);
16786
16787 /* outputs */
16788 {
16789 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
16790 calloc(1, sizeof(struct _ssPortOutputs));
16791 ss_VALIDATE_MEMORY(rts,outputPortInfo);
16792 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
16793 _ssSetNumOutputPorts(childS, 1);
16794
16795 /* port 0 */
16796 {
16797 _ssSetOutputPortNumDimensions(childS, 0, 1);
16798 ssSetOutputPortWidth(childS, 0, 1);
16799 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
16800 ssGetLocalBlockIO(rts))->GeneratedSFunction_f));
16801 }
16802 }
16803
16804 /* path info */
16805 _ssSetModelName(childS, "Gain_sf");
16806 _ssSetPath(childS,
16807 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/gain2/Generated S-Function");
16808 if (ssGetRTModel(rts) == (NULL)) {
16809 _ssSetParentSS(childS, rts);
16810 _ssSetRootSS(childS, ssGetRootSS(rts));
16811 } else {
16812 ssSetRTModel(childS,ssGetRTModel(rts));
16813 _ssSetParentSS(childS, (NULL));
16814 _ssSetRootSS(childS, childS);
16815 }
16816
16817 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
16818 (childS)->regDataType.arg1 = ((void *)(childS));
16819 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
16820 FcnSetErrorStatus);
16821 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
16822 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
16823 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
16824 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
16825
16826 /* registration */
16827#if defined(MATLAB_MEX_FILE)
16828
16829 {
16830 int_T i;
16831 mxArray *plhs[1];
16832 mxArray *prhs[4];
16833 double *pr;
16834 volatile int_T *intS = (int_T *)&childS;
16835 int_T addrlen = sizeof(SimStruct *);
16836 int_T m = addrlen/sizeof(int_T) + 1;
16837 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
16838 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
16839 pr = mxGetPr(prhs[1]);
16840 for (i = 0; i < m - 1; i++) {
16841 pr[i] = (double)intS[i];
16842 }
16843
16844 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
16845 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
16846 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
16847
16848 /* Reset port dimensions info functions because the S-function
16849 * and accelerator mex-files explicitly set their dimensions,
16850 * i.e., they are not dynamically sized. For this case, the
16851 * mex-file is responsible for the dimensions info memory
16852 * and Simulink should not free it. This is achieved by
16853 * setting the following two methods to NULL.
16854 */
16855 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
16856 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
16857
16858 /*
16859 * Setup function pointers and call mdlInitializeSizes via
16860 * simulink.c
16861 */
16862 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
16863 mxDestroyArray(plhs[0]);
16864 mxDestroyArray(prhs[0]);
16865 mxDestroyArray(prhs[1]);
16866 mxDestroyArray(prhs[2]);
16867 mxDestroyArray(prhs[3]);
16868 }
16869
16870#else
16871
16872 {
16873 Gain_sf(childS);
16874 sfcnInitializeSizes(childS);
16875 }
16876
16877#endif
16878
16879 sfcnInitializeSampleTimes(childS);
16880
16881 /* adjust sample time */
16882 ssSetSampleTime(childS, 0, 0.0);
16883 ssSetOffsetTime(childS, 0, 0.0);
16884 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
16885
16886 /* set compiled values of dynamic vector attributes */
16887 ssSetNumNonsampledZCs(childS, 0);
16888
16889 /* Update connectivity flags for each port */
16890 _ssSetInputPortConnected(childS, 0, 1);
16891 _ssSetInputPortConnected(childS, 1, 1);
16892 _ssSetOutputPortConnected(childS, 0, 1);
16893 _ssSetOutputPortBeingMerged(childS, 0, 0);
16894
16895 /* Update the BufferDstPort flags for each input port */
16896 _ssSetInputPortBufferDstPort(childS, 0, -1);
16897 _ssSetInputPortBufferDstPort(childS, 1, -1);
16898 }
16899
16900 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S152>/Generated S-Function2 (LeadLagFilter_sf) */
16901 {
16902 SimStruct *childS = ssGetSFunction(rts, 63);
16903
16904 /* timing info */
16905 time_T *sfcnPeriod;
16906 time_T *sfcnOffset;
16907 int_T *sfcnTsMap;
16908 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
16909 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
16910 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
16911 ss_VALIDATE_MEMORY(rts,sfcnOffset);
16912 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
16913 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
16914 (void) memset((void*)sfcnPeriod, 0,
16915 sizeof(time_T)*1);
16916 (void) memset((void*)sfcnOffset, 0,
16917 sizeof(time_T)*1);
16918 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
16919 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
16920 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
16921
16922 /* Set up the mdlInfo pointer */
16923# ifdef USE_RTMODEL
16924
16925 {
16926 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
16927 struct _ssBlkInfo2));
16928 ss_VALIDATE_MEMORY(rts,blkInfo2);
16929 ssSetBlkInfo2Ptr(childS, blkInfo2);
16930 }
16931
16932 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
16933
16934# else
16935
16936 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
16937
16938# endif /* USE_RTMODEL */
16939
16940 /* Allocate memory of model methods 2 */
16941 {
16942 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
16943 malloc(sizeof(struct _ssSFcnModelMethods2));
16944 ss_VALIDATE_MEMORY(rts,methods2);
16945 ssSetModelMethods2(childS, methods2);
16946 }
16947
16948 /* Allocate memory of model methods 3 */
16949 {
16950 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
16951 malloc(sizeof(struct _ssSFcnModelMethods3));
16952 ss_VALIDATE_MEMORY(rts,methods3);
16953 ssSetModelMethods3(childS, methods3);
16954 }
16955
16956 /* Allocate memory for states auxilliary information */
16957 {
16958 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
16959 (sizeof(struct _ssStatesInfo2));
16960 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
16961 malloc(sizeof(ssPeriodicStatesInfo));
16962 ss_VALIDATE_MEMORY(rts,statesInfo2);
16963 ssSetStatesInfo2(childS, statesInfo2);
16964 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
16965 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
16966 }
16967
16968 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
16969 RegNumInputPorts);
16970 ssSetRegNumInputPortsFcnArg(childS,childS);
16971
16972 /* inputs */
16973 {
16974 struct _ssPortInputs *inputPortInfo =
16975 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
16976 ss_VALIDATE_MEMORY(rts,inputPortInfo);
16977 _ssSetNumInputPorts(childS, 7);
16978 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
16979
16980 /* port 0 */
16981 {
16982 real32_T const **sfcnUPtrs = (real32_T const **)
16983 malloc(1 * sizeof(real32_T *));
16984 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16985 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
16986 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
16987 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
16988 _ssSetInputPortNumDimensions(childS, 0, 1);
16989 ssSetInputPortWidth(childS, 0, 1);
16990 }
16991
16992 /* port 1 */
16993 {
16994 int8_T const **sfcnUPtrs = (int8_T const **)
16995 malloc(1 * sizeof(int8_T *));
16996 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
16997 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
16998 ssGetLocalBlockIO(rts))->DataTypeConversion1_h;
16999 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
17000 _ssSetInputPortNumDimensions(childS, 1, 1);
17001 ssSetInputPortWidth(childS, 1, 1);
17002 }
17003
17004 /* port 2 */
17005 {
17006 real32_T const **sfcnUPtrs = (real32_T const **)
17007 malloc(1 * sizeof(real32_T *));
17008 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17009 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
17010 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
17011 _ssSetInputPortNumDimensions(childS, 2, 1);
17012 ssSetInputPortWidth(childS, 2, 1);
17013 }
17014
17015 /* port 3 */
17016 {
17017 real32_T const **sfcnUPtrs = (real32_T const **)
17018 malloc(1 * sizeof(real32_T *));
17019 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17020 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
17021 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
17022 _ssSetInputPortNumDimensions(childS, 3, 1);
17023 ssSetInputPortWidth(childS, 3, 1);
17024 }
17025
17026 /* port 4 */
17027 {
17028 real32_T const **sfcnUPtrs = (real32_T const **)
17029 malloc(1 * sizeof(real32_T *));
17030 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17031 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
17032 ssGetLocalBlockIO(rts))->Sum4_d;
17033 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
17034 _ssSetInputPortNumDimensions(childS, 4, 1);
17035 ssSetInputPortWidth(childS, 4, 1);
17036 }
17037
17038 /* port 5 */
17039 {
17040 real32_T const **sfcnUPtrs = (real32_T const **)
17041 malloc(1 * sizeof(real32_T *));
17042 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17043 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
17044 ssGetLocalBlockIO(rts))->Sum4_d;
17045 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
17046 _ssSetInputPortNumDimensions(childS, 5, 1);
17047 ssSetInputPortWidth(childS, 5, 1);
17048 }
17049
17050 /* port 6 */
17051 {
17052 real32_T const **sfcnUPtrs = (real32_T const **)
17053 malloc(1 * sizeof(real32_T *));
17054 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17055 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
17056 ssGetLocalBlockIO(rts))->GeneratedSFunction_f;
17057 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
17058 _ssSetInputPortNumDimensions(childS, 6, 1);
17059 ssSetInputPortWidth(childS, 6, 1);
17060 }
17061 }
17062
17063 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
17064 RegNumOutputPorts);
17065 ssSetRegNumOutputPortsFcnArg(childS,childS);
17066
17067 /* outputs */
17068 {
17069 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
17070 calloc(1, sizeof(struct _ssPortOutputs));
17071 ss_VALIDATE_MEMORY(rts,outputPortInfo);
17072 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
17073 _ssSetNumOutputPorts(childS, 1);
17074
17075 /* port 0 */
17076 {
17077 _ssSetOutputPortNumDimensions(childS, 0, 1);
17078 ssSetOutputPortWidth(childS, 0, 1);
17079 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
17080 ssGetLocalBlockIO(rts))->Saturation2_p));
17081 }
17082 }
17083
17084 /* path info */
17085 _ssSetModelName(childS, "LeadLagFilter_sf");
17086 _ssSetPath(childS,
17087 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Lead lag1/Generated S-Function2");
17088 if (ssGetRTModel(rts) == (NULL)) {
17089 _ssSetParentSS(childS, rts);
17090 _ssSetRootSS(childS, ssGetRootSS(rts));
17091 } else {
17092 ssSetRTModel(childS,ssGetRTModel(rts));
17093 _ssSetParentSS(childS, (NULL));
17094 _ssSetRootSS(childS, childS);
17095 }
17096
17097 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
17098
17099 /* work vectors */
17100 {
17101 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
17102 (4 * sizeof(struct _ssDWorkRecord));
17103 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
17104 calloc(4, sizeof(struct _ssDWorkAuxRecord));
17105 ss_VALIDATE_MEMORY(rts,dWorkRecord);
17106 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
17107 ssSetSFcnDWork(childS, dWorkRecord);
17108 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
17109 _ssSetNumDWork(childS, 4);
17110
17111 /* DWORK0 */
17112 ssSetDWorkWidth(childS, 0, 1);
17113 ssSetDWorkDataType(childS, 0,SS_SINGLE);
17114 ssSetDWorkComplexSignal(childS, 0, 0);
17115 ssSetDWorkUsedAsDState(childS, 0, 1);
17116 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 198))[0]);
17117
17118 /* DWORK1 */
17119 ssSetDWorkWidth(childS, 1, 1);
17120 ssSetDWorkDataType(childS, 1,SS_SINGLE);
17121 ssSetDWorkComplexSignal(childS, 1, 0);
17122 ssSetDWorkUsedAsDState(childS, 1, 1);
17123 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 199))[0]);
17124
17125 /* DWORK2 */
17126 ssSetDWorkWidth(childS, 2, 1);
17127 ssSetDWorkDataType(childS, 2,SS_INT8);
17128 ssSetDWorkComplexSignal(childS, 2, 0);
17129 ssSetDWorkUsedAsDState(childS, 2, 1);
17130 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 425))[0]);
17131
17132 /* DWORK3 */
17133 ssSetDWorkWidth(childS, 3, 1);
17134 ssSetDWorkDataType(childS, 3,SS_INT8);
17135 ssSetDWorkComplexSignal(childS, 3, 0);
17136 ssSetDWorkUsedAsDState(childS, 3, 1);
17137 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 426))[0]);
17138 }
17139
17140 (childS)->regDataType.arg1 = ((void *)(childS));
17141 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
17142 FcnSetErrorStatus);
17143 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
17144 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
17145 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
17146 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
17147
17148 /* registration */
17149#if defined(MATLAB_MEX_FILE)
17150
17151 {
17152 int_T i;
17153 mxArray *plhs[1];
17154 mxArray *prhs[4];
17155 double *pr;
17156 volatile int_T *intS = (int_T *)&childS;
17157 int_T addrlen = sizeof(SimStruct *);
17158 int_T m = addrlen/sizeof(int_T) + 1;
17159 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
17160 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
17161 pr = mxGetPr(prhs[1]);
17162 for (i = 0; i < m - 1; i++) {
17163 pr[i] = (double)intS[i];
17164 }
17165
17166 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
17167 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
17168 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
17169
17170 /* Reset port dimensions info functions because the S-function
17171 * and accelerator mex-files explicitly set their dimensions,
17172 * i.e., they are not dynamically sized. For this case, the
17173 * mex-file is responsible for the dimensions info memory
17174 * and Simulink should not free it. This is achieved by
17175 * setting the following two methods to NULL.
17176 */
17177 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
17178 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
17179
17180 /*
17181 * Setup function pointers and call mdlInitializeSizes via
17182 * simulink.c
17183 */
17184 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
17185 mxDestroyArray(plhs[0]);
17186 mxDestroyArray(prhs[0]);
17187 mxDestroyArray(prhs[1]);
17188 mxDestroyArray(prhs[2]);
17189 mxDestroyArray(prhs[3]);
17190 }
17191
17192#else
17193
17194 {
17195 LeadLagFilter_sf(childS);
17196 sfcnInitializeSizes(childS);
17197 }
17198
17199#endif
17200
17201 sfcnInitializeSampleTimes(childS);
17202
17203 /* adjust sample time */
17204 ssSetSampleTime(childS, 0, 0.0);
17205 ssSetOffsetTime(childS, 0, 0.0);
17206 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
17207
17208 /* set compiled values of dynamic vector attributes */
17209 ssSetNumNonsampledZCs(childS, 0);
17210
17211 /* Update connectivity flags for each port */
17212 _ssSetInputPortConnected(childS, 0, 1);
17213 _ssSetInputPortConnected(childS, 1, 1);
17214 _ssSetInputPortConnected(childS, 2, 1);
17215 _ssSetInputPortConnected(childS, 3, 1);
17216 _ssSetInputPortConnected(childS, 4, 1);
17217 _ssSetInputPortConnected(childS, 5, 1);
17218 _ssSetInputPortConnected(childS, 6, 1);
17219 _ssSetOutputPortConnected(childS, 0, 1);
17220 _ssSetOutputPortBeingMerged(childS, 0, 0);
17221
17222 /* Update the BufferDstPort flags for each input port */
17223 _ssSetInputPortBufferDstPort(childS, 0, -1);
17224 _ssSetInputPortBufferDstPort(childS, 1, -1);
17225 _ssSetInputPortBufferDstPort(childS, 2, -1);
17226 _ssSetInputPortBufferDstPort(childS, 3, -1);
17227 _ssSetInputPortBufferDstPort(childS, 4, -1);
17228 _ssSetInputPortBufferDstPort(childS, 5, -1);
17229 _ssSetInputPortBufferDstPort(childS, 6, -1);
17230 }
17231
17232 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S128>/Generated S-Function1 (Res180_sf) */
17233 {
17234 SimStruct *childS = ssGetSFunction(rts, 64);
17235
17236 /* timing info */
17237 time_T *sfcnPeriod;
17238 time_T *sfcnOffset;
17239 int_T *sfcnTsMap;
17240 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
17241 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
17242 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
17243 ss_VALIDATE_MEMORY(rts,sfcnOffset);
17244 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
17245 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
17246 (void) memset((void*)sfcnPeriod, 0,
17247 sizeof(time_T)*1);
17248 (void) memset((void*)sfcnOffset, 0,
17249 sizeof(time_T)*1);
17250 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
17251 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
17252 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
17253
17254 /* Set up the mdlInfo pointer */
17255# ifdef USE_RTMODEL
17256
17257 {
17258 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
17259 struct _ssBlkInfo2));
17260 ss_VALIDATE_MEMORY(rts,blkInfo2);
17261 ssSetBlkInfo2Ptr(childS, blkInfo2);
17262 }
17263
17264 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
17265
17266# else
17267
17268 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
17269
17270# endif /* USE_RTMODEL */
17271
17272 /* Allocate memory of model methods 2 */
17273 {
17274 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
17275 malloc(sizeof(struct _ssSFcnModelMethods2));
17276 ss_VALIDATE_MEMORY(rts,methods2);
17277 ssSetModelMethods2(childS, methods2);
17278 }
17279
17280 /* Allocate memory of model methods 3 */
17281 {
17282 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
17283 malloc(sizeof(struct _ssSFcnModelMethods3));
17284 ss_VALIDATE_MEMORY(rts,methods3);
17285 ssSetModelMethods3(childS, methods3);
17286 }
17287
17288 /* Allocate memory for states auxilliary information */
17289 {
17290 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
17291 (sizeof(struct _ssStatesInfo2));
17292 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
17293 malloc(sizeof(ssPeriodicStatesInfo));
17294 ss_VALIDATE_MEMORY(rts,statesInfo2);
17295 ssSetStatesInfo2(childS, statesInfo2);
17296 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
17297 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
17298 }
17299
17300 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
17301 RegNumInputPorts);
17302 ssSetRegNumInputPortsFcnArg(childS,childS);
17303
17304 /* inputs */
17305 {
17306 struct _ssPortInputs *inputPortInfo =
17307 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
17308 ss_VALIDATE_MEMORY(rts,inputPortInfo);
17309 _ssSetNumInputPorts(childS, 1);
17310 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
17311
17312 /* port 0 */
17313 {
17314 real32_T const **sfcnUPtrs = (real32_T const **)
17315 malloc(1 * sizeof(real32_T *));
17316 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17317 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
17318 ssGetLocalBlockIO(rts))->Sum1_g;
17319 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
17320 _ssSetInputPortNumDimensions(childS, 0, 1);
17321 ssSetInputPortWidth(childS, 0, 1);
17322 }
17323 }
17324
17325 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
17326 RegNumOutputPorts);
17327 ssSetRegNumOutputPortsFcnArg(childS,childS);
17328
17329 /* outputs */
17330 {
17331 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
17332 calloc(1, sizeof(struct _ssPortOutputs));
17333 ss_VALIDATE_MEMORY(rts,outputPortInfo);
17334 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
17335 _ssSetNumOutputPorts(childS, 1);
17336
17337 /* port 0 */
17338 {
17339 _ssSetOutputPortNumDimensions(childS, 0, 1);
17340 ssSetOutputPortWidth(childS, 0, 1);
17341 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
17342 ssGetLocalBlockIO(rts))->GeneratedSFunction1_hp));
17343 }
17344 }
17345
17346 /* path info */
17347 _ssSetModelName(childS, "Res180_sf");
17348 _ssSetPath(childS,
17349 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Generated S-Function1");
17350 if (ssGetRTModel(rts) == (NULL)) {
17351 _ssSetParentSS(childS, rts);
17352 _ssSetRootSS(childS, ssGetRootSS(rts));
17353 } else {
17354 ssSetRTModel(childS,ssGetRTModel(rts));
17355 _ssSetParentSS(childS, (NULL));
17356 _ssSetRootSS(childS, childS);
17357 }
17358
17359 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
17360 (childS)->regDataType.arg1 = ((void *)(childS));
17361 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
17362 FcnSetErrorStatus);
17363 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
17364 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
17365 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
17366 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
17367
17368 /* registration */
17369#if defined(MATLAB_MEX_FILE)
17370
17371 {
17372 int_T i;
17373 mxArray *plhs[1];
17374 mxArray *prhs[4];
17375 double *pr;
17376 volatile int_T *intS = (int_T *)&childS;
17377 int_T addrlen = sizeof(SimStruct *);
17378 int_T m = addrlen/sizeof(int_T) + 1;
17379 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
17380 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
17381 pr = mxGetPr(prhs[1]);
17382 for (i = 0; i < m - 1; i++) {
17383 pr[i] = (double)intS[i];
17384 }
17385
17386 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
17387 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
17388 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
17389
17390 /* Reset port dimensions info functions because the S-function
17391 * and accelerator mex-files explicitly set their dimensions,
17392 * i.e., they are not dynamically sized. For this case, the
17393 * mex-file is responsible for the dimensions info memory
17394 * and Simulink should not free it. This is achieved by
17395 * setting the following two methods to NULL.
17396 */
17397 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
17398 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
17399
17400 /*
17401 * Setup function pointers and call mdlInitializeSizes via
17402 * simulink.c
17403 */
17404 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
17405 mxDestroyArray(plhs[0]);
17406 mxDestroyArray(prhs[0]);
17407 mxDestroyArray(prhs[1]);
17408 mxDestroyArray(prhs[2]);
17409 mxDestroyArray(prhs[3]);
17410 }
17411
17412#else
17413
17414 {
17415 Res180_sf(childS);
17416 sfcnInitializeSizes(childS);
17417 }
17418
17419#endif
17420
17421 sfcnInitializeSampleTimes(childS);
17422
17423 /* adjust sample time */
17424 ssSetSampleTime(childS, 0, 0.0);
17425 ssSetOffsetTime(childS, 0, 0.0);
17426 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
17427
17428 /* set compiled values of dynamic vector attributes */
17429 ssSetNumNonsampledZCs(childS, 0);
17430
17431 /* Update connectivity flags for each port */
17432 _ssSetInputPortConnected(childS, 0, 1);
17433 _ssSetOutputPortConnected(childS, 0, 1);
17434 _ssSetOutputPortBeingMerged(childS, 0, 0);
17435
17436 /* Update the BufferDstPort flags for each input port */
17437 _ssSetInputPortBufferDstPort(childS, 0, -1);
17438 }
17439
17440 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S153>/Generated S-Function1 (SaturationLimiter_sf) */
17441 {
17442 SimStruct *childS = ssGetSFunction(rts, 65);
17443
17444 /* timing info */
17445 time_T *sfcnPeriod;
17446 time_T *sfcnOffset;
17447 int_T *sfcnTsMap;
17448 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
17449 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
17450 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
17451 ss_VALIDATE_MEMORY(rts,sfcnOffset);
17452 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
17453 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
17454 (void) memset((void*)sfcnPeriod, 0,
17455 sizeof(time_T)*1);
17456 (void) memset((void*)sfcnOffset, 0,
17457 sizeof(time_T)*1);
17458 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
17459 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
17460 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
17461
17462 /* Set up the mdlInfo pointer */
17463# ifdef USE_RTMODEL
17464
17465 {
17466 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
17467 struct _ssBlkInfo2));
17468 ss_VALIDATE_MEMORY(rts,blkInfo2);
17469 ssSetBlkInfo2Ptr(childS, blkInfo2);
17470 }
17471
17472 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
17473
17474# else
17475
17476 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
17477
17478# endif /* USE_RTMODEL */
17479
17480 /* Allocate memory of model methods 2 */
17481 {
17482 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
17483 malloc(sizeof(struct _ssSFcnModelMethods2));
17484 ss_VALIDATE_MEMORY(rts,methods2);
17485 ssSetModelMethods2(childS, methods2);
17486 }
17487
17488 /* Allocate memory of model methods 3 */
17489 {
17490 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
17491 malloc(sizeof(struct _ssSFcnModelMethods3));
17492 ss_VALIDATE_MEMORY(rts,methods3);
17493 ssSetModelMethods3(childS, methods3);
17494 }
17495
17496 /* Allocate memory for states auxilliary information */
17497 {
17498 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
17499 (sizeof(struct _ssStatesInfo2));
17500 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
17501 malloc(sizeof(ssPeriodicStatesInfo));
17502 ss_VALIDATE_MEMORY(rts,statesInfo2);
17503 ssSetStatesInfo2(childS, statesInfo2);
17504 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
17505 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
17506 }
17507
17508 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
17509 RegNumInputPorts);
17510 ssSetRegNumInputPortsFcnArg(childS,childS);
17511
17512 /* inputs */
17513 {
17514 struct _ssPortInputs *inputPortInfo =
17515 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
17516 ss_VALIDATE_MEMORY(rts,inputPortInfo);
17517 _ssSetNumInputPorts(childS, 3);
17518 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
17519
17520 /* port 0 */
17521 {
17522 real32_T const **sfcnUPtrs = (real32_T const **)
17523 malloc(1 * sizeof(real32_T *));
17524 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17525 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
17526 ssGetLocalBlockIO(rts))->GeneratedSFunction1_hp;
17527 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
17528 _ssSetInputPortNumDimensions(childS, 0, 1);
17529 ssSetInputPortWidth(childS, 0, 1);
17530 }
17531
17532 /* port 1 */
17533 {
17534 real32_T const **sfcnUPtrs = (real32_T const **)
17535 malloc(1 * sizeof(real32_T *));
17536 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17537 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
17538 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
17539 _ssSetInputPortNumDimensions(childS, 1, 1);
17540 ssSetInputPortWidth(childS, 1, 1);
17541 }
17542
17543 /* port 2 */
17544 {
17545 real32_T const **sfcnUPtrs = (real32_T const **)
17546 malloc(1 * sizeof(real32_T *));
17547 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17548 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;
17549 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
17550 _ssSetInputPortNumDimensions(childS, 2, 1);
17551 ssSetInputPortWidth(childS, 2, 1);
17552 }
17553 }
17554
17555 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
17556 RegNumOutputPorts);
17557 ssSetRegNumOutputPortsFcnArg(childS,childS);
17558
17559 /* outputs */
17560 {
17561 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
17562 calloc(1, sizeof(struct _ssPortOutputs));
17563 ss_VALIDATE_MEMORY(rts,outputPortInfo);
17564 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
17565 _ssSetNumOutputPorts(childS, 1);
17566
17567 /* port 0 */
17568 {
17569 _ssSetOutputPortNumDimensions(childS, 0, 1);
17570 ssSetOutputPortWidth(childS, 0, 1);
17571 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
17572 ssGetLocalBlockIO(rts))->GeneratedSFunction1_oq));
17573 }
17574 }
17575
17576 /* path info */
17577 _ssSetModelName(childS, "SaturationLimiter_sf");
17578 _ssSetPath(childS,
17579 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Saturation Limiter/Generated S-Function1");
17580 if (ssGetRTModel(rts) == (NULL)) {
17581 _ssSetParentSS(childS, rts);
17582 _ssSetRootSS(childS, ssGetRootSS(rts));
17583 } else {
17584 ssSetRTModel(childS,ssGetRTModel(rts));
17585 _ssSetParentSS(childS, (NULL));
17586 _ssSetRootSS(childS, childS);
17587 }
17588
17589 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
17590 (childS)->regDataType.arg1 = ((void *)(childS));
17591 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
17592 FcnSetErrorStatus);
17593 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
17594 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
17595 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
17596 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
17597
17598 /* registration */
17599#if defined(MATLAB_MEX_FILE)
17600
17601 {
17602 int_T i;
17603 mxArray *plhs[1];
17604 mxArray *prhs[4];
17605 double *pr;
17606 volatile int_T *intS = (int_T *)&childS;
17607 int_T addrlen = sizeof(SimStruct *);
17608 int_T m = addrlen/sizeof(int_T) + 1;
17609 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
17610 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
17611 pr = mxGetPr(prhs[1]);
17612 for (i = 0; i < m - 1; i++) {
17613 pr[i] = (double)intS[i];
17614 }
17615
17616 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
17617 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
17618 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
17619
17620 /* Reset port dimensions info functions because the S-function
17621 * and accelerator mex-files explicitly set their dimensions,
17622 * i.e., they are not dynamically sized. For this case, the
17623 * mex-file is responsible for the dimensions info memory
17624 * and Simulink should not free it. This is achieved by
17625 * setting the following two methods to NULL.
17626 */
17627 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
17628 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
17629
17630 /*
17631 * Setup function pointers and call mdlInitializeSizes via
17632 * simulink.c
17633 */
17634 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
17635 mxDestroyArray(plhs[0]);
17636 mxDestroyArray(prhs[0]);
17637 mxDestroyArray(prhs[1]);
17638 mxDestroyArray(prhs[2]);
17639 mxDestroyArray(prhs[3]);
17640 }
17641
17642#else
17643
17644 {
17645 SaturationLimiter_sf(childS);
17646 sfcnInitializeSizes(childS);
17647 }
17648
17649#endif
17650
17651 sfcnInitializeSampleTimes(childS);
17652
17653 /* adjust sample time */
17654 ssSetSampleTime(childS, 0, 0.0);
17655 ssSetOffsetTime(childS, 0, 0.0);
17656 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
17657
17658 /* set compiled values of dynamic vector attributes */
17659 ssSetNumNonsampledZCs(childS, 0);
17660
17661 /* Update connectivity flags for each port */
17662 _ssSetInputPortConnected(childS, 0, 1);
17663 _ssSetInputPortConnected(childS, 1, 1);
17664 _ssSetInputPortConnected(childS, 2, 1);
17665 _ssSetOutputPortConnected(childS, 0, 1);
17666 _ssSetOutputPortBeingMerged(childS, 0, 0);
17667
17668 /* Update the BufferDstPort flags for each input port */
17669 _ssSetInputPortBufferDstPort(childS, 0, -1);
17670 _ssSetInputPortBufferDstPort(childS, 1, -1);
17671 _ssSetInputPortBufferDstPort(childS, 2, -1);
17672 }
17673
17674 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S156>/Generated S-Function (Gain_sf) */
17675 {
17676 SimStruct *childS = ssGetSFunction(rts, 66);
17677
17678 /* timing info */
17679 time_T *sfcnPeriod;
17680 time_T *sfcnOffset;
17681 int_T *sfcnTsMap;
17682 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
17683 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
17684 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
17685 ss_VALIDATE_MEMORY(rts,sfcnOffset);
17686 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
17687 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
17688 (void) memset((void*)sfcnPeriod, 0,
17689 sizeof(time_T)*1);
17690 (void) memset((void*)sfcnOffset, 0,
17691 sizeof(time_T)*1);
17692 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
17693 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
17694 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
17695
17696 /* Set up the mdlInfo pointer */
17697# ifdef USE_RTMODEL
17698
17699 {
17700 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
17701 struct _ssBlkInfo2));
17702 ss_VALIDATE_MEMORY(rts,blkInfo2);
17703 ssSetBlkInfo2Ptr(childS, blkInfo2);
17704 }
17705
17706 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
17707
17708# else
17709
17710 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
17711
17712# endif /* USE_RTMODEL */
17713
17714 /* Allocate memory of model methods 2 */
17715 {
17716 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
17717 malloc(sizeof(struct _ssSFcnModelMethods2));
17718 ss_VALIDATE_MEMORY(rts,methods2);
17719 ssSetModelMethods2(childS, methods2);
17720 }
17721
17722 /* Allocate memory of model methods 3 */
17723 {
17724 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
17725 malloc(sizeof(struct _ssSFcnModelMethods3));
17726 ss_VALIDATE_MEMORY(rts,methods3);
17727 ssSetModelMethods3(childS, methods3);
17728 }
17729
17730 /* Allocate memory for states auxilliary information */
17731 {
17732 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
17733 (sizeof(struct _ssStatesInfo2));
17734 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
17735 malloc(sizeof(ssPeriodicStatesInfo));
17736 ss_VALIDATE_MEMORY(rts,statesInfo2);
17737 ssSetStatesInfo2(childS, statesInfo2);
17738 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
17739 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
17740 }
17741
17742 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
17743 RegNumInputPorts);
17744 ssSetRegNumInputPortsFcnArg(childS,childS);
17745
17746 /* inputs */
17747 {
17748 struct _ssPortInputs *inputPortInfo =
17749 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
17750 ss_VALIDATE_MEMORY(rts,inputPortInfo);
17751 _ssSetNumInputPorts(childS, 2);
17752 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
17753
17754 /* port 0 */
17755 {
17756 real32_T const **sfcnUPtrs = (real32_T const **)
17757 malloc(1 * sizeof(real32_T *));
17758 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17759 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
17760 ssGetLocalBlockIO(rts))->GeneratedSFunction1_oq;
17761 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
17762 _ssSetInputPortNumDimensions(childS, 0, 1);
17763 ssSetInputPortWidth(childS, 0, 1);
17764 }
17765
17766 /* port 1 */
17767 {
17768 real32_T const **sfcnUPtrs = (real32_T const **)
17769 malloc(1 * sizeof(real32_T *));
17770 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17771 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
17772 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
17773 _ssSetInputPortNumDimensions(childS, 1, 1);
17774 ssSetInputPortWidth(childS, 1, 1);
17775 }
17776 }
17777
17778 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
17779 RegNumOutputPorts);
17780 ssSetRegNumOutputPortsFcnArg(childS,childS);
17781
17782 /* outputs */
17783 {
17784 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
17785 calloc(1, sizeof(struct _ssPortOutputs));
17786 ss_VALIDATE_MEMORY(rts,outputPortInfo);
17787 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
17788 _ssSetNumOutputPorts(childS, 1);
17789
17790 /* port 0 */
17791 {
17792 _ssSetOutputPortNumDimensions(childS, 0, 1);
17793 ssSetOutputPortWidth(childS, 0, 1);
17794 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
17795 ssGetLocalBlockIO(rts))->GeneratedSFunction_ex));
17796 }
17797 }
17798
17799 /* path info */
17800 _ssSetModelName(childS, "Gain_sf");
17801 _ssSetPath(childS,
17802 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/gain/Generated S-Function");
17803 if (ssGetRTModel(rts) == (NULL)) {
17804 _ssSetParentSS(childS, rts);
17805 _ssSetRootSS(childS, ssGetRootSS(rts));
17806 } else {
17807 ssSetRTModel(childS,ssGetRTModel(rts));
17808 _ssSetParentSS(childS, (NULL));
17809 _ssSetRootSS(childS, childS);
17810 }
17811
17812 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
17813 (childS)->regDataType.arg1 = ((void *)(childS));
17814 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
17815 FcnSetErrorStatus);
17816 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
17817 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
17818 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
17819 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
17820
17821 /* registration */
17822#if defined(MATLAB_MEX_FILE)
17823
17824 {
17825 int_T i;
17826 mxArray *plhs[1];
17827 mxArray *prhs[4];
17828 double *pr;
17829 volatile int_T *intS = (int_T *)&childS;
17830 int_T addrlen = sizeof(SimStruct *);
17831 int_T m = addrlen/sizeof(int_T) + 1;
17832 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
17833 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
17834 pr = mxGetPr(prhs[1]);
17835 for (i = 0; i < m - 1; i++) {
17836 pr[i] = (double)intS[i];
17837 }
17838
17839 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
17840 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
17841 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
17842
17843 /* Reset port dimensions info functions because the S-function
17844 * and accelerator mex-files explicitly set their dimensions,
17845 * i.e., they are not dynamically sized. For this case, the
17846 * mex-file is responsible for the dimensions info memory
17847 * and Simulink should not free it. This is achieved by
17848 * setting the following two methods to NULL.
17849 */
17850 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
17851 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
17852
17853 /*
17854 * Setup function pointers and call mdlInitializeSizes via
17855 * simulink.c
17856 */
17857 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
17858 mxDestroyArray(plhs[0]);
17859 mxDestroyArray(prhs[0]);
17860 mxDestroyArray(prhs[1]);
17861 mxDestroyArray(prhs[2]);
17862 mxDestroyArray(prhs[3]);
17863 }
17864
17865#else
17866
17867 {
17868 Gain_sf(childS);
17869 sfcnInitializeSizes(childS);
17870 }
17871
17872#endif
17873
17874 sfcnInitializeSampleTimes(childS);
17875
17876 /* adjust sample time */
17877 ssSetSampleTime(childS, 0, 0.0);
17878 ssSetOffsetTime(childS, 0, 0.0);
17879 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
17880
17881 /* set compiled values of dynamic vector attributes */
17882 ssSetNumNonsampledZCs(childS, 0);
17883
17884 /* Update connectivity flags for each port */
17885 _ssSetInputPortConnected(childS, 0, 1);
17886 _ssSetInputPortConnected(childS, 1, 1);
17887 _ssSetOutputPortConnected(childS, 0, 1);
17888 _ssSetOutputPortBeingMerged(childS, 0, 0);
17889
17890 /* Update the BufferDstPort flags for each input port */
17891 _ssSetInputPortBufferDstPort(childS, 0, -1);
17892 _ssSetInputPortBufferDstPort(childS, 1, -1);
17893 }
17894
17895 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S157>/Generated S-Function (Gain_sf) */
17896 {
17897 SimStruct *childS = ssGetSFunction(rts, 67);
17898
17899 /* timing info */
17900 time_T *sfcnPeriod;
17901 time_T *sfcnOffset;
17902 int_T *sfcnTsMap;
17903 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
17904 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
17905 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
17906 ss_VALIDATE_MEMORY(rts,sfcnOffset);
17907 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
17908 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
17909 (void) memset((void*)sfcnPeriod, 0,
17910 sizeof(time_T)*1);
17911 (void) memset((void*)sfcnOffset, 0,
17912 sizeof(time_T)*1);
17913 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
17914 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
17915 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
17916
17917 /* Set up the mdlInfo pointer */
17918# ifdef USE_RTMODEL
17919
17920 {
17921 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
17922 struct _ssBlkInfo2));
17923 ss_VALIDATE_MEMORY(rts,blkInfo2);
17924 ssSetBlkInfo2Ptr(childS, blkInfo2);
17925 }
17926
17927 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
17928
17929# else
17930
17931 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
17932
17933# endif /* USE_RTMODEL */
17934
17935 /* Allocate memory of model methods 2 */
17936 {
17937 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
17938 malloc(sizeof(struct _ssSFcnModelMethods2));
17939 ss_VALIDATE_MEMORY(rts,methods2);
17940 ssSetModelMethods2(childS, methods2);
17941 }
17942
17943 /* Allocate memory of model methods 3 */
17944 {
17945 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
17946 malloc(sizeof(struct _ssSFcnModelMethods3));
17947 ss_VALIDATE_MEMORY(rts,methods3);
17948 ssSetModelMethods3(childS, methods3);
17949 }
17950
17951 /* Allocate memory for states auxilliary information */
17952 {
17953 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
17954 (sizeof(struct _ssStatesInfo2));
17955 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
17956 malloc(sizeof(ssPeriodicStatesInfo));
17957 ss_VALIDATE_MEMORY(rts,statesInfo2);
17958 ssSetStatesInfo2(childS, statesInfo2);
17959 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
17960 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
17961 }
17962
17963 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
17964 RegNumInputPorts);
17965 ssSetRegNumInputPortsFcnArg(childS,childS);
17966
17967 /* inputs */
17968 {
17969 struct _ssPortInputs *inputPortInfo =
17970 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
17971 ss_VALIDATE_MEMORY(rts,inputPortInfo);
17972 _ssSetNumInputPorts(childS, 2);
17973 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
17974
17975 /* port 0 */
17976 {
17977 real32_T const **sfcnUPtrs = (real32_T const **)
17978 malloc(1 * sizeof(real32_T *));
17979 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17980 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
17981 ssGetLocalBlockIO(rts))->GeneratedSFunction_ex;
17982 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
17983 _ssSetInputPortNumDimensions(childS, 0, 1);
17984 ssSetInputPortWidth(childS, 0, 1);
17985 }
17986
17987 /* port 1 */
17988 {
17989 real32_T const **sfcnUPtrs = (real32_T const **)
17990 malloc(1 * sizeof(real32_T *));
17991 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
17992 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
17993 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
17994 _ssSetInputPortNumDimensions(childS, 1, 1);
17995 ssSetInputPortWidth(childS, 1, 1);
17996 }
17997 }
17998
17999 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
18000 RegNumOutputPorts);
18001 ssSetRegNumOutputPortsFcnArg(childS,childS);
18002
18003 /* outputs */
18004 {
18005 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
18006 calloc(1, sizeof(struct _ssPortOutputs));
18007 ss_VALIDATE_MEMORY(rts,outputPortInfo);
18008 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
18009 _ssSetNumOutputPorts(childS, 1);
18010
18011 /* port 0 */
18012 {
18013 _ssSetOutputPortNumDimensions(childS, 0, 1);
18014 ssSetOutputPortWidth(childS, 0, 1);
18015 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
18016 ssGetLocalBlockIO(rts))->GeneratedSFunction_nh));
18017 }
18018 }
18019
18020 /* path info */
18021 _ssSetModelName(childS, "Gain_sf");
18022 _ssSetPath(childS,
18023 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/gain1/Generated S-Function");
18024 if (ssGetRTModel(rts) == (NULL)) {
18025 _ssSetParentSS(childS, rts);
18026 _ssSetRootSS(childS, ssGetRootSS(rts));
18027 } else {
18028 ssSetRTModel(childS,ssGetRTModel(rts));
18029 _ssSetParentSS(childS, (NULL));
18030 _ssSetRootSS(childS, childS);
18031 }
18032
18033 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
18034 (childS)->regDataType.arg1 = ((void *)(childS));
18035 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
18036 FcnSetErrorStatus);
18037 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
18038 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
18039 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
18040 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
18041
18042 /* registration */
18043#if defined(MATLAB_MEX_FILE)
18044
18045 {
18046 int_T i;
18047 mxArray *plhs[1];
18048 mxArray *prhs[4];
18049 double *pr;
18050 volatile int_T *intS = (int_T *)&childS;
18051 int_T addrlen = sizeof(SimStruct *);
18052 int_T m = addrlen/sizeof(int_T) + 1;
18053 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
18054 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
18055 pr = mxGetPr(prhs[1]);
18056 for (i = 0; i < m - 1; i++) {
18057 pr[i] = (double)intS[i];
18058 }
18059
18060 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
18061 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
18062 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
18063
18064 /* Reset port dimensions info functions because the S-function
18065 * and accelerator mex-files explicitly set their dimensions,
18066 * i.e., they are not dynamically sized. For this case, the
18067 * mex-file is responsible for the dimensions info memory
18068 * and Simulink should not free it. This is achieved by
18069 * setting the following two methods to NULL.
18070 */
18071 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
18072 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
18073
18074 /*
18075 * Setup function pointers and call mdlInitializeSizes via
18076 * simulink.c
18077 */
18078 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
18079 mxDestroyArray(plhs[0]);
18080 mxDestroyArray(prhs[0]);
18081 mxDestroyArray(prhs[1]);
18082 mxDestroyArray(prhs[2]);
18083 mxDestroyArray(prhs[3]);
18084 }
18085
18086#else
18087
18088 {
18089 Gain_sf(childS);
18090 sfcnInitializeSizes(childS);
18091 }
18092
18093#endif
18094
18095 sfcnInitializeSampleTimes(childS);
18096
18097 /* adjust sample time */
18098 ssSetSampleTime(childS, 0, 0.0);
18099 ssSetOffsetTime(childS, 0, 0.0);
18100 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
18101
18102 /* set compiled values of dynamic vector attributes */
18103 ssSetNumNonsampledZCs(childS, 0);
18104
18105 /* Update connectivity flags for each port */
18106 _ssSetInputPortConnected(childS, 0, 1);
18107 _ssSetInputPortConnected(childS, 1, 1);
18108 _ssSetOutputPortConnected(childS, 0, 1);
18109 _ssSetOutputPortBeingMerged(childS, 0, 0);
18110
18111 /* Update the BufferDstPort flags for each input port */
18112 _ssSetInputPortBufferDstPort(childS, 0, -1);
18113 _ssSetInputPortBufferDstPort(childS, 1, -1);
18114 }
18115
18116 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S150>/Generated S-Function3 (IntegratorLimited_sf) */
18117 {
18118 SimStruct *childS = ssGetSFunction(rts, 68);
18119
18120 /* timing info */
18121 time_T *sfcnPeriod;
18122 time_T *sfcnOffset;
18123 int_T *sfcnTsMap;
18124 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
18125 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
18126 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
18127 ss_VALIDATE_MEMORY(rts,sfcnOffset);
18128 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
18129 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
18130 (void) memset((void*)sfcnPeriod, 0,
18131 sizeof(time_T)*1);
18132 (void) memset((void*)sfcnOffset, 0,
18133 sizeof(time_T)*1);
18134 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
18135 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
18136 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
18137
18138 /* Set up the mdlInfo pointer */
18139# ifdef USE_RTMODEL
18140
18141 {
18142 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
18143 struct _ssBlkInfo2));
18144 ss_VALIDATE_MEMORY(rts,blkInfo2);
18145 ssSetBlkInfo2Ptr(childS, blkInfo2);
18146 }
18147
18148 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
18149
18150# else
18151
18152 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
18153
18154# endif /* USE_RTMODEL */
18155
18156 /* Allocate memory of model methods 2 */
18157 {
18158 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
18159 malloc(sizeof(struct _ssSFcnModelMethods2));
18160 ss_VALIDATE_MEMORY(rts,methods2);
18161 ssSetModelMethods2(childS, methods2);
18162 }
18163
18164 /* Allocate memory of model methods 3 */
18165 {
18166 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
18167 malloc(sizeof(struct _ssSFcnModelMethods3));
18168 ss_VALIDATE_MEMORY(rts,methods3);
18169 ssSetModelMethods3(childS, methods3);
18170 }
18171
18172 /* Allocate memory for states auxilliary information */
18173 {
18174 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
18175 (sizeof(struct _ssStatesInfo2));
18176 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
18177 malloc(sizeof(ssPeriodicStatesInfo));
18178 ss_VALIDATE_MEMORY(rts,statesInfo2);
18179 ssSetStatesInfo2(childS, statesInfo2);
18180 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
18181 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
18182 }
18183
18184 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
18185 RegNumInputPorts);
18186 ssSetRegNumInputPortsFcnArg(childS,childS);
18187
18188 /* inputs */
18189 {
18190 struct _ssPortInputs *inputPortInfo =
18191 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
18192 ss_VALIDATE_MEMORY(rts,inputPortInfo);
18193 _ssSetNumInputPorts(childS, 7);
18194 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
18195
18196 /* port 0 */
18197 {
18198 real32_T const **sfcnUPtrs = (real32_T const **)
18199 malloc(1 * sizeof(real32_T *));
18200 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18201 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18202 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
18203 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
18204 _ssSetInputPortNumDimensions(childS, 0, 1);
18205 ssSetInputPortWidth(childS, 0, 1);
18206 }
18207
18208 /* port 1 */
18209 {
18210 int8_T const **sfcnUPtrs = (int8_T const **)
18211 malloc(1 * sizeof(int8_T *));
18212 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18213 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
18214 ssGetLocalBlockIO(rts))->DataTypeConversion1_h;
18215 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
18216 _ssSetInputPortNumDimensions(childS, 1, 1);
18217 ssSetInputPortWidth(childS, 1, 1);
18218 }
18219
18220 /* port 2 */
18221 {
18222 real32_T const **sfcnUPtrs = (real32_T const **)
18223 malloc(1 * sizeof(real32_T *));
18224 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18225 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
18226 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
18227 _ssSetInputPortNumDimensions(childS, 2, 1);
18228 ssSetInputPortWidth(childS, 2, 1);
18229 }
18230
18231 /* port 3 */
18232 {
18233 real32_T const **sfcnUPtrs = (real32_T const **)
18234 malloc(1 * sizeof(real32_T *));
18235 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18236 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
18237 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
18238 _ssSetInputPortNumDimensions(childS, 3, 1);
18239 ssSetInputPortWidth(childS, 3, 1);
18240 }
18241
18242 /* port 4 */
18243 {
18244 real32_T const **sfcnUPtrs = (real32_T const **)
18245 malloc(1 * sizeof(real32_T *));
18246 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18247 sfcnUPtrs[0] = (real32_T const *)
18248 &AFCS_MODEL1_ConstP.Constant29_Value;
18249 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
18250 _ssSetInputPortNumDimensions(childS, 4, 1);
18251 ssSetInputPortWidth(childS, 4, 1);
18252 }
18253
18254 /* port 5 */
18255 {
18256 real32_T const **sfcnUPtrs = (real32_T const **)
18257 malloc(1 * sizeof(real32_T *));
18258 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18259 sfcnUPtrs[0] = (real32_T const *)
18260 &AFCS_MODEL1_ConstP.Constant30_Value;
18261 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
18262 _ssSetInputPortNumDimensions(childS, 5, 1);
18263 ssSetInputPortWidth(childS, 5, 1);
18264 }
18265
18266 /* port 6 */
18267 {
18268 real32_T const **sfcnUPtrs = (real32_T const **)
18269 malloc(1 * sizeof(real32_T *));
18270 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18271 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18272 ssGetLocalBlockIO(rts))->GeneratedSFunction_nh;
18273 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
18274 _ssSetInputPortNumDimensions(childS, 6, 1);
18275 ssSetInputPortWidth(childS, 6, 1);
18276 }
18277 }
18278
18279 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
18280 RegNumOutputPorts);
18281 ssSetRegNumOutputPortsFcnArg(childS,childS);
18282
18283 /* outputs */
18284 {
18285 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
18286 calloc(1, sizeof(struct _ssPortOutputs));
18287 ss_VALIDATE_MEMORY(rts,outputPortInfo);
18288 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
18289 _ssSetNumOutputPorts(childS, 1);
18290
18291 /* port 0 */
18292 {
18293 _ssSetOutputPortNumDimensions(childS, 0, 1);
18294 ssSetOutputPortWidth(childS, 0, 1);
18295 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
18296 ssGetLocalBlockIO(rts))->Saturation2_p));
18297 }
18298 }
18299
18300 /* path info */
18301 _ssSetModelName(childS, "IntegratorLimited_sf");
18302 _ssSetPath(childS,
18303 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Integrator Limited/Generated S-Function3");
18304 if (ssGetRTModel(rts) == (NULL)) {
18305 _ssSetParentSS(childS, rts);
18306 _ssSetRootSS(childS, ssGetRootSS(rts));
18307 } else {
18308 ssSetRTModel(childS,ssGetRTModel(rts));
18309 _ssSetParentSS(childS, (NULL));
18310 _ssSetRootSS(childS, childS);
18311 }
18312
18313 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
18314
18315 /* work vectors */
18316 {
18317 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
18318 (4 * sizeof(struct _ssDWorkRecord));
18319 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
18320 calloc(4, sizeof(struct _ssDWorkAuxRecord));
18321 ss_VALIDATE_MEMORY(rts,dWorkRecord);
18322 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
18323 ssSetSFcnDWork(childS, dWorkRecord);
18324 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
18325 _ssSetNumDWork(childS, 4);
18326
18327 /* DWORK0 */
18328 ssSetDWorkWidth(childS, 0, 1);
18329 ssSetDWorkDataType(childS, 0,SS_SINGLE);
18330 ssSetDWorkComplexSignal(childS, 0, 0);
18331 ssSetDWorkUsedAsDState(childS, 0, 1);
18332 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 200))[0]);
18333
18334 /* DWORK1 */
18335 ssSetDWorkWidth(childS, 1, 1);
18336 ssSetDWorkDataType(childS, 1,SS_SINGLE);
18337 ssSetDWorkComplexSignal(childS, 1, 0);
18338 ssSetDWorkUsedAsDState(childS, 1, 1);
18339 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 201))[0]);
18340
18341 /* DWORK2 */
18342 ssSetDWorkWidth(childS, 2, 1);
18343 ssSetDWorkDataType(childS, 2,SS_INT8);
18344 ssSetDWorkComplexSignal(childS, 2, 0);
18345 ssSetDWorkUsedAsDState(childS, 2, 1);
18346 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 427))[0]);
18347
18348 /* DWORK3 */
18349 ssSetDWorkWidth(childS, 3, 1);
18350 ssSetDWorkDataType(childS, 3,SS_INT8);
18351 ssSetDWorkComplexSignal(childS, 3, 0);
18352 ssSetDWorkUsedAsDState(childS, 3, 1);
18353 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 428))[0]);
18354 }
18355
18356 (childS)->regDataType.arg1 = ((void *)(childS));
18357 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
18358 FcnSetErrorStatus);
18359 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
18360 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
18361 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
18362 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
18363
18364 /* registration */
18365#if defined(MATLAB_MEX_FILE)
18366
18367 {
18368 int_T i;
18369 mxArray *plhs[1];
18370 mxArray *prhs[4];
18371 double *pr;
18372 volatile int_T *intS = (int_T *)&childS;
18373 int_T addrlen = sizeof(SimStruct *);
18374 int_T m = addrlen/sizeof(int_T) + 1;
18375 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
18376 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
18377 pr = mxGetPr(prhs[1]);
18378 for (i = 0; i < m - 1; i++) {
18379 pr[i] = (double)intS[i];
18380 }
18381
18382 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
18383 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
18384 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
18385
18386 /* Reset port dimensions info functions because the S-function
18387 * and accelerator mex-files explicitly set their dimensions,
18388 * i.e., they are not dynamically sized. For this case, the
18389 * mex-file is responsible for the dimensions info memory
18390 * and Simulink should not free it. This is achieved by
18391 * setting the following two methods to NULL.
18392 */
18393 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
18394 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
18395
18396 /*
18397 * Setup function pointers and call mdlInitializeSizes via
18398 * simulink.c
18399 */
18400 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
18401 mxDestroyArray(plhs[0]);
18402 mxDestroyArray(prhs[0]);
18403 mxDestroyArray(prhs[1]);
18404 mxDestroyArray(prhs[2]);
18405 mxDestroyArray(prhs[3]);
18406 }
18407
18408#else
18409
18410 {
18411 IntegratorLimited_sf(childS);
18412 sfcnInitializeSizes(childS);
18413 }
18414
18415#endif
18416
18417 sfcnInitializeSampleTimes(childS);
18418
18419 /* adjust sample time */
18420 ssSetSampleTime(childS, 0, 0.0);
18421 ssSetOffsetTime(childS, 0, 0.0);
18422 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
18423
18424 /* set compiled values of dynamic vector attributes */
18425 ssSetNumNonsampledZCs(childS, 0);
18426
18427 /* Update connectivity flags for each port */
18428 _ssSetInputPortConnected(childS, 0, 1);
18429 _ssSetInputPortConnected(childS, 1, 1);
18430 _ssSetInputPortConnected(childS, 2, 1);
18431 _ssSetInputPortConnected(childS, 3, 1);
18432 _ssSetInputPortConnected(childS, 4, 1);
18433 _ssSetInputPortConnected(childS, 5, 1);
18434 _ssSetInputPortConnected(childS, 6, 1);
18435 _ssSetOutputPortConnected(childS, 0, 1);
18436 _ssSetOutputPortBeingMerged(childS, 0, 0);
18437
18438 /* Update the BufferDstPort flags for each input port */
18439 _ssSetInputPortBufferDstPort(childS, 0, -1);
18440 _ssSetInputPortBufferDstPort(childS, 1, -1);
18441 _ssSetInputPortBufferDstPort(childS, 2, -1);
18442 _ssSetInputPortBufferDstPort(childS, 3, -1);
18443 _ssSetInputPortBufferDstPort(childS, 4, -1);
18444 _ssSetInputPortBufferDstPort(childS, 5, -1);
18445 _ssSetInputPortBufferDstPort(childS, 6, -1);
18446 }
18447
18448 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S151>/Generated S-Function2 (LeadLagFilter_sf) */
18449 {
18450 SimStruct *childS = ssGetSFunction(rts, 69);
18451
18452 /* timing info */
18453 time_T *sfcnPeriod;
18454 time_T *sfcnOffset;
18455 int_T *sfcnTsMap;
18456 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
18457 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
18458 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
18459 ss_VALIDATE_MEMORY(rts,sfcnOffset);
18460 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
18461 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
18462 (void) memset((void*)sfcnPeriod, 0,
18463 sizeof(time_T)*1);
18464 (void) memset((void*)sfcnOffset, 0,
18465 sizeof(time_T)*1);
18466 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
18467 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
18468 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
18469
18470 /* Set up the mdlInfo pointer */
18471# ifdef USE_RTMODEL
18472
18473 {
18474 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
18475 struct _ssBlkInfo2));
18476 ss_VALIDATE_MEMORY(rts,blkInfo2);
18477 ssSetBlkInfo2Ptr(childS, blkInfo2);
18478 }
18479
18480 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
18481
18482# else
18483
18484 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
18485
18486# endif /* USE_RTMODEL */
18487
18488 /* Allocate memory of model methods 2 */
18489 {
18490 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
18491 malloc(sizeof(struct _ssSFcnModelMethods2));
18492 ss_VALIDATE_MEMORY(rts,methods2);
18493 ssSetModelMethods2(childS, methods2);
18494 }
18495
18496 /* Allocate memory of model methods 3 */
18497 {
18498 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
18499 malloc(sizeof(struct _ssSFcnModelMethods3));
18500 ss_VALIDATE_MEMORY(rts,methods3);
18501 ssSetModelMethods3(childS, methods3);
18502 }
18503
18504 /* Allocate memory for states auxilliary information */
18505 {
18506 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
18507 (sizeof(struct _ssStatesInfo2));
18508 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
18509 malloc(sizeof(ssPeriodicStatesInfo));
18510 ss_VALIDATE_MEMORY(rts,statesInfo2);
18511 ssSetStatesInfo2(childS, statesInfo2);
18512 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
18513 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
18514 }
18515
18516 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
18517 RegNumInputPorts);
18518 ssSetRegNumInputPortsFcnArg(childS,childS);
18519
18520 /* inputs */
18521 {
18522 struct _ssPortInputs *inputPortInfo =
18523 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
18524 ss_VALIDATE_MEMORY(rts,inputPortInfo);
18525 _ssSetNumInputPorts(childS, 7);
18526 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
18527
18528 /* port 0 */
18529 {
18530 real32_T const **sfcnUPtrs = (real32_T const **)
18531 malloc(1 * sizeof(real32_T *));
18532 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18533 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18534 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
18535 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
18536 _ssSetInputPortNumDimensions(childS, 0, 1);
18537 ssSetInputPortWidth(childS, 0, 1);
18538 }
18539
18540 /* port 1 */
18541 {
18542 int8_T const **sfcnUPtrs = (int8_T const **)
18543 malloc(1 * sizeof(int8_T *));
18544 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18545 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
18546 ssGetLocalBlockIO(rts))->DataTypeConversion1_h;
18547 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
18548 _ssSetInputPortNumDimensions(childS, 1, 1);
18549 ssSetInputPortWidth(childS, 1, 1);
18550 }
18551
18552 /* port 2 */
18553 {
18554 real32_T const **sfcnUPtrs = (real32_T const **)
18555 malloc(1 * sizeof(real32_T *));
18556 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18557 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
18558 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
18559 _ssSetInputPortNumDimensions(childS, 2, 1);
18560 ssSetInputPortWidth(childS, 2, 1);
18561 }
18562
18563 /* port 3 */
18564 {
18565 real32_T const **sfcnUPtrs = (real32_T const **)
18566 malloc(1 * sizeof(real32_T *));
18567 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18568 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
18569 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
18570 _ssSetInputPortNumDimensions(childS, 3, 1);
18571 ssSetInputPortWidth(childS, 3, 1);
18572 }
18573
18574 /* port 4 */
18575 {
18576 real32_T const **sfcnUPtrs = (real32_T const **)
18577 malloc(1 * sizeof(real32_T *));
18578 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18579 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18580 ssGetLocalBlockIO(rts))->Switch_bg;
18581 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
18582 _ssSetInputPortNumDimensions(childS, 4, 1);
18583 ssSetInputPortWidth(childS, 4, 1);
18584 }
18585
18586 /* port 5 */
18587 {
18588 real32_T const **sfcnUPtrs = (real32_T const **)
18589 malloc(1 * sizeof(real32_T *));
18590 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18591 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18592 ssGetLocalBlockIO(rts))->Switch_bg;
18593 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
18594 _ssSetInputPortNumDimensions(childS, 5, 1);
18595 ssSetInputPortWidth(childS, 5, 1);
18596 }
18597
18598 /* port 6 */
18599 {
18600 real32_T const **sfcnUPtrs = (real32_T const **)
18601 malloc(1 * sizeof(real32_T *));
18602 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18603 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18604 ssGetLocalBlockIO(rts))->Sum_d;
18605 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
18606 _ssSetInputPortNumDimensions(childS, 6, 1);
18607 ssSetInputPortWidth(childS, 6, 1);
18608 }
18609 }
18610
18611 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
18612 RegNumOutputPorts);
18613 ssSetRegNumOutputPortsFcnArg(childS,childS);
18614
18615 /* outputs */
18616 {
18617 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
18618 calloc(1, sizeof(struct _ssPortOutputs));
18619 ss_VALIDATE_MEMORY(rts,outputPortInfo);
18620 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
18621 _ssSetNumOutputPorts(childS, 1);
18622
18623 /* port 0 */
18624 {
18625 _ssSetOutputPortNumDimensions(childS, 0, 1);
18626 ssSetOutputPortWidth(childS, 0, 1);
18627 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
18628 ssGetLocalBlockIO(rts))->GeneratedSFunction2_i));
18629 }
18630 }
18631
18632 /* path info */
18633 _ssSetModelName(childS, "LeadLagFilter_sf");
18634 _ssSetPath(childS,
18635 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/Lead lag/Generated S-Function2");
18636 if (ssGetRTModel(rts) == (NULL)) {
18637 _ssSetParentSS(childS, rts);
18638 _ssSetRootSS(childS, ssGetRootSS(rts));
18639 } else {
18640 ssSetRTModel(childS,ssGetRTModel(rts));
18641 _ssSetParentSS(childS, (NULL));
18642 _ssSetRootSS(childS, childS);
18643 }
18644
18645 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
18646
18647 /* work vectors */
18648 {
18649 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
18650 (4 * sizeof(struct _ssDWorkRecord));
18651 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
18652 calloc(4, sizeof(struct _ssDWorkAuxRecord));
18653 ss_VALIDATE_MEMORY(rts,dWorkRecord);
18654 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
18655 ssSetSFcnDWork(childS, dWorkRecord);
18656 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
18657 _ssSetNumDWork(childS, 4);
18658
18659 /* DWORK0 */
18660 ssSetDWorkWidth(childS, 0, 1);
18661 ssSetDWorkDataType(childS, 0,SS_SINGLE);
18662 ssSetDWorkComplexSignal(childS, 0, 0);
18663 ssSetDWorkUsedAsDState(childS, 0, 1);
18664 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 202))[0]);
18665
18666 /* DWORK1 */
18667 ssSetDWorkWidth(childS, 1, 1);
18668 ssSetDWorkDataType(childS, 1,SS_SINGLE);
18669 ssSetDWorkComplexSignal(childS, 1, 0);
18670 ssSetDWorkUsedAsDState(childS, 1, 1);
18671 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 203))[0]);
18672
18673 /* DWORK2 */
18674 ssSetDWorkWidth(childS, 2, 1);
18675 ssSetDWorkDataType(childS, 2,SS_INT8);
18676 ssSetDWorkComplexSignal(childS, 2, 0);
18677 ssSetDWorkUsedAsDState(childS, 2, 1);
18678 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 429))[0]);
18679
18680 /* DWORK3 */
18681 ssSetDWorkWidth(childS, 3, 1);
18682 ssSetDWorkDataType(childS, 3,SS_INT8);
18683 ssSetDWorkComplexSignal(childS, 3, 0);
18684 ssSetDWorkUsedAsDState(childS, 3, 1);
18685 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 430))[0]);
18686 }
18687
18688 (childS)->regDataType.arg1 = ((void *)(childS));
18689 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
18690 FcnSetErrorStatus);
18691 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
18692 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
18693 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
18694 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
18695
18696 /* registration */
18697#if defined(MATLAB_MEX_FILE)
18698
18699 {
18700 int_T i;
18701 mxArray *plhs[1];
18702 mxArray *prhs[4];
18703 double *pr;
18704 volatile int_T *intS = (int_T *)&childS;
18705 int_T addrlen = sizeof(SimStruct *);
18706 int_T m = addrlen/sizeof(int_T) + 1;
18707 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
18708 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
18709 pr = mxGetPr(prhs[1]);
18710 for (i = 0; i < m - 1; i++) {
18711 pr[i] = (double)intS[i];
18712 }
18713
18714 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
18715 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
18716 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
18717
18718 /* Reset port dimensions info functions because the S-function
18719 * and accelerator mex-files explicitly set their dimensions,
18720 * i.e., they are not dynamically sized. For this case, the
18721 * mex-file is responsible for the dimensions info memory
18722 * and Simulink should not free it. This is achieved by
18723 * setting the following two methods to NULL.
18724 */
18725 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
18726 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
18727
18728 /*
18729 * Setup function pointers and call mdlInitializeSizes via
18730 * simulink.c
18731 */
18732 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
18733 mxDestroyArray(plhs[0]);
18734 mxDestroyArray(prhs[0]);
18735 mxDestroyArray(prhs[1]);
18736 mxDestroyArray(prhs[2]);
18737 mxDestroyArray(prhs[3]);
18738 }
18739
18740#else
18741
18742 {
18743 LeadLagFilter_sf(childS);
18744 sfcnInitializeSizes(childS);
18745 }
18746
18747#endif
18748
18749 sfcnInitializeSampleTimes(childS);
18750
18751 /* adjust sample time */
18752 ssSetSampleTime(childS, 0, 0.0);
18753 ssSetOffsetTime(childS, 0, 0.0);
18754 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
18755
18756 /* set compiled values of dynamic vector attributes */
18757 ssSetNumNonsampledZCs(childS, 0);
18758
18759 /* Update connectivity flags for each port */
18760 _ssSetInputPortConnected(childS, 0, 1);
18761 _ssSetInputPortConnected(childS, 1, 1);
18762 _ssSetInputPortConnected(childS, 2, 1);
18763 _ssSetInputPortConnected(childS, 3, 1);
18764 _ssSetInputPortConnected(childS, 4, 1);
18765 _ssSetInputPortConnected(childS, 5, 1);
18766 _ssSetInputPortConnected(childS, 6, 1);
18767 _ssSetOutputPortConnected(childS, 0, 1);
18768 _ssSetOutputPortBeingMerged(childS, 0, 0);
18769
18770 /* Update the BufferDstPort flags for each input port */
18771 _ssSetInputPortBufferDstPort(childS, 0, -1);
18772 _ssSetInputPortBufferDstPort(childS, 1, -1);
18773 _ssSetInputPortBufferDstPort(childS, 2, -1);
18774 _ssSetInputPortBufferDstPort(childS, 3, -1);
18775 _ssSetInputPortBufferDstPort(childS, 4, -1);
18776 _ssSetInputPortBufferDstPort(childS, 5, -1);
18777 _ssSetInputPortBufferDstPort(childS, 6, -1);
18778 }
18779
18780 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S149>/Generated S-Function4 (LagFilter_sf) */
18781 {
18782 SimStruct *childS = ssGetSFunction(rts, 70);
18783
18784 /* timing info */
18785 time_T *sfcnPeriod;
18786 time_T *sfcnOffset;
18787 int_T *sfcnTsMap;
18788 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
18789 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
18790 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
18791 ss_VALIDATE_MEMORY(rts,sfcnOffset);
18792 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
18793 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
18794 (void) memset((void*)sfcnPeriod, 0,
18795 sizeof(time_T)*1);
18796 (void) memset((void*)sfcnOffset, 0,
18797 sizeof(time_T)*1);
18798 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
18799 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
18800 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
18801
18802 /* Set up the mdlInfo pointer */
18803# ifdef USE_RTMODEL
18804
18805 {
18806 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
18807 struct _ssBlkInfo2));
18808 ss_VALIDATE_MEMORY(rts,blkInfo2);
18809 ssSetBlkInfo2Ptr(childS, blkInfo2);
18810 }
18811
18812 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
18813
18814# else
18815
18816 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
18817
18818# endif /* USE_RTMODEL */
18819
18820 /* Allocate memory of model methods 2 */
18821 {
18822 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
18823 malloc(sizeof(struct _ssSFcnModelMethods2));
18824 ss_VALIDATE_MEMORY(rts,methods2);
18825 ssSetModelMethods2(childS, methods2);
18826 }
18827
18828 /* Allocate memory of model methods 3 */
18829 {
18830 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
18831 malloc(sizeof(struct _ssSFcnModelMethods3));
18832 ss_VALIDATE_MEMORY(rts,methods3);
18833 ssSetModelMethods3(childS, methods3);
18834 }
18835
18836 /* Allocate memory for states auxilliary information */
18837 {
18838 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
18839 (sizeof(struct _ssStatesInfo2));
18840 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
18841 malloc(sizeof(ssPeriodicStatesInfo));
18842 ss_VALIDATE_MEMORY(rts,statesInfo2);
18843 ssSetStatesInfo2(childS, statesInfo2);
18844 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
18845 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
18846 }
18847
18848 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
18849 RegNumInputPorts);
18850 ssSetRegNumInputPortsFcnArg(childS,childS);
18851
18852 /* inputs */
18853 {
18854 struct _ssPortInputs *inputPortInfo =
18855 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
18856 ss_VALIDATE_MEMORY(rts,inputPortInfo);
18857 _ssSetNumInputPorts(childS, 6);
18858 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
18859
18860 /* port 0 */
18861 {
18862 real32_T const **sfcnUPtrs = (real32_T const **)
18863 malloc(1 * sizeof(real32_T *));
18864 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18865 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18866 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
18867 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
18868 _ssSetInputPortNumDimensions(childS, 0, 1);
18869 ssSetInputPortWidth(childS, 0, 1);
18870 }
18871
18872 /* port 1 */
18873 {
18874 int8_T const **sfcnUPtrs = (int8_T const **)
18875 malloc(1 * sizeof(int8_T *));
18876 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18877 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
18878 ssGetLocalBlockIO(rts))->DataTypeConversion1_h;
18879 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
18880 _ssSetInputPortNumDimensions(childS, 1, 1);
18881 ssSetInputPortWidth(childS, 1, 1);
18882 }
18883
18884 /* port 2 */
18885 {
18886 real32_T const **sfcnUPtrs = (real32_T const **)
18887 malloc(1 * sizeof(real32_T *));
18888 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18889 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
18890 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
18891 _ssSetInputPortNumDimensions(childS, 2, 1);
18892 ssSetInputPortWidth(childS, 2, 1);
18893 }
18894
18895 /* port 3 */
18896 {
18897 real32_T const **sfcnUPtrs = (real32_T const **)
18898 malloc(1 * sizeof(real32_T *));
18899 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18900 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18901 ssGetLocalBlockIO(rts))->Switch_bg;
18902 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
18903 _ssSetInputPortNumDimensions(childS, 3, 1);
18904 ssSetInputPortWidth(childS, 3, 1);
18905 }
18906
18907 /* port 4 */
18908 {
18909 real32_T const **sfcnUPtrs = (real32_T const **)
18910 malloc(1 * sizeof(real32_T *));
18911 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18912 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18913 ssGetLocalBlockIO(rts))->Switch_bg;
18914 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
18915 _ssSetInputPortNumDimensions(childS, 4, 1);
18916 ssSetInputPortWidth(childS, 4, 1);
18917 }
18918
18919 /* port 5 */
18920 {
18921 real32_T const **sfcnUPtrs = (real32_T const **)
18922 malloc(1 * sizeof(real32_T *));
18923 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
18924 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
18925 ssGetLocalBlockIO(rts))->GeneratedSFunction2_i;
18926 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
18927 _ssSetInputPortNumDimensions(childS, 5, 1);
18928 ssSetInputPortWidth(childS, 5, 1);
18929 }
18930 }
18931
18932 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
18933 RegNumOutputPorts);
18934 ssSetRegNumOutputPortsFcnArg(childS,childS);
18935
18936 /* outputs */
18937 {
18938 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
18939 calloc(1, sizeof(struct _ssPortOutputs));
18940 ss_VALIDATE_MEMORY(rts,outputPortInfo);
18941 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
18942 _ssSetNumOutputPorts(childS, 1);
18943
18944 /* port 0 */
18945 {
18946 _ssSetOutputPortNumDimensions(childS, 0, 1);
18947 ssSetOutputPortWidth(childS, 0, 1);
18948 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
18949 ssGetLocalBlockIO(rts))->GeneratedSFunction4_dc));
18950 }
18951 }
18952
18953 /* path info */
18954 _ssSetModelName(childS, "LagFilter_sf");
18955 _ssSetPath(childS,
18956 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsiLControl/ lag filter/Generated S-Function4");
18957 if (ssGetRTModel(rts) == (NULL)) {
18958 _ssSetParentSS(childS, rts);
18959 _ssSetRootSS(childS, ssGetRootSS(rts));
18960 } else {
18961 ssSetRTModel(childS,ssGetRTModel(rts));
18962 _ssSetParentSS(childS, (NULL));
18963 _ssSetRootSS(childS, childS);
18964 }
18965
18966 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
18967
18968 /* work vectors */
18969 {
18970 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
18971 (4 * sizeof(struct _ssDWorkRecord));
18972 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
18973 calloc(4, sizeof(struct _ssDWorkAuxRecord));
18974 ss_VALIDATE_MEMORY(rts,dWorkRecord);
18975 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
18976 ssSetSFcnDWork(childS, dWorkRecord);
18977 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
18978 _ssSetNumDWork(childS, 4);
18979
18980 /* DWORK0 */
18981 ssSetDWorkWidth(childS, 0, 1);
18982 ssSetDWorkDataType(childS, 0,SS_SINGLE);
18983 ssSetDWorkComplexSignal(childS, 0, 0);
18984 ssSetDWorkUsedAsDState(childS, 0, 1);
18985 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 204))[0]);
18986
18987 /* DWORK1 */
18988 ssSetDWorkWidth(childS, 1, 1);
18989 ssSetDWorkDataType(childS, 1,SS_SINGLE);
18990 ssSetDWorkComplexSignal(childS, 1, 0);
18991 ssSetDWorkUsedAsDState(childS, 1, 1);
18992 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 205))[0]);
18993
18994 /* DWORK2 */
18995 ssSetDWorkWidth(childS, 2, 1);
18996 ssSetDWorkDataType(childS, 2,SS_INT8);
18997 ssSetDWorkComplexSignal(childS, 2, 0);
18998 ssSetDWorkUsedAsDState(childS, 2, 1);
18999 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 431))[0]);
19000
19001 /* DWORK3 */
19002 ssSetDWorkWidth(childS, 3, 1);
19003 ssSetDWorkDataType(childS, 3,SS_INT8);
19004 ssSetDWorkComplexSignal(childS, 3, 0);
19005 ssSetDWorkUsedAsDState(childS, 3, 1);
19006 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 432))[0]);
19007 }
19008
19009 (childS)->regDataType.arg1 = ((void *)(childS));
19010 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
19011 FcnSetErrorStatus);
19012 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
19013 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
19014 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
19015 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
19016
19017 /* registration */
19018#if defined(MATLAB_MEX_FILE)
19019
19020 {
19021 int_T i;
19022 mxArray *plhs[1];
19023 mxArray *prhs[4];
19024 double *pr;
19025 volatile int_T *intS = (int_T *)&childS;
19026 int_T addrlen = sizeof(SimStruct *);
19027 int_T m = addrlen/sizeof(int_T) + 1;
19028 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
19029 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
19030 pr = mxGetPr(prhs[1]);
19031 for (i = 0; i < m - 1; i++) {
19032 pr[i] = (double)intS[i];
19033 }
19034
19035 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
19036 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
19037 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
19038
19039 /* Reset port dimensions info functions because the S-function
19040 * and accelerator mex-files explicitly set their dimensions,
19041 * i.e., they are not dynamically sized. For this case, the
19042 * mex-file is responsible for the dimensions info memory
19043 * and Simulink should not free it. This is achieved by
19044 * setting the following two methods to NULL.
19045 */
19046 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
19047 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
19048
19049 /*
19050 * Setup function pointers and call mdlInitializeSizes via
19051 * simulink.c
19052 */
19053 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
19054 mxDestroyArray(plhs[0]);
19055 mxDestroyArray(prhs[0]);
19056 mxDestroyArray(prhs[1]);
19057 mxDestroyArray(prhs[2]);
19058 mxDestroyArray(prhs[3]);
19059 }
19060
19061#else
19062
19063 {
19064 LagFilter_sf(childS);
19065 sfcnInitializeSizes(childS);
19066 }
19067
19068#endif
19069
19070 sfcnInitializeSampleTimes(childS);
19071
19072 /* adjust sample time */
19073 ssSetSampleTime(childS, 0, 0.0);
19074 ssSetOffsetTime(childS, 0, 0.0);
19075 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
19076
19077 /* set compiled values of dynamic vector attributes */
19078 ssSetNumNonsampledZCs(childS, 0);
19079
19080 /* Update connectivity flags for each port */
19081 _ssSetInputPortConnected(childS, 0, 1);
19082 _ssSetInputPortConnected(childS, 1, 1);
19083 _ssSetInputPortConnected(childS, 2, 1);
19084 _ssSetInputPortConnected(childS, 3, 1);
19085 _ssSetInputPortConnected(childS, 4, 1);
19086 _ssSetInputPortConnected(childS, 5, 1);
19087 _ssSetOutputPortConnected(childS, 0, 1);
19088 _ssSetOutputPortBeingMerged(childS, 0, 0);
19089
19090 /* Update the BufferDstPort flags for each input port */
19091 _ssSetInputPortBufferDstPort(childS, 0, -1);
19092 _ssSetInputPortBufferDstPort(childS, 1, -1);
19093 _ssSetInputPortBufferDstPort(childS, 2, -1);
19094 _ssSetInputPortBufferDstPort(childS, 3, -1);
19095 _ssSetInputPortBufferDstPort(childS, 4, -1);
19096 _ssSetInputPortBufferDstPort(childS, 5, -1);
19097 }
19098
19099 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S145>/Generated S-Function1 (SaturationLimiter_sf) */
19100 {
19101 SimStruct *childS = ssGetSFunction(rts, 71);
19102
19103 /* timing info */
19104 time_T *sfcnPeriod;
19105 time_T *sfcnOffset;
19106 int_T *sfcnTsMap;
19107 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
19108 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
19109 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
19110 ss_VALIDATE_MEMORY(rts,sfcnOffset);
19111 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
19112 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
19113 (void) memset((void*)sfcnPeriod, 0,
19114 sizeof(time_T)*1);
19115 (void) memset((void*)sfcnOffset, 0,
19116 sizeof(time_T)*1);
19117 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
19118 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
19119 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
19120
19121 /* Set up the mdlInfo pointer */
19122# ifdef USE_RTMODEL
19123
19124 {
19125 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
19126 struct _ssBlkInfo2));
19127 ss_VALIDATE_MEMORY(rts,blkInfo2);
19128 ssSetBlkInfo2Ptr(childS, blkInfo2);
19129 }
19130
19131 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
19132
19133# else
19134
19135 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
19136
19137# endif /* USE_RTMODEL */
19138
19139 /* Allocate memory of model methods 2 */
19140 {
19141 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
19142 malloc(sizeof(struct _ssSFcnModelMethods2));
19143 ss_VALIDATE_MEMORY(rts,methods2);
19144 ssSetModelMethods2(childS, methods2);
19145 }
19146
19147 /* Allocate memory of model methods 3 */
19148 {
19149 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
19150 malloc(sizeof(struct _ssSFcnModelMethods3));
19151 ss_VALIDATE_MEMORY(rts,methods3);
19152 ssSetModelMethods3(childS, methods3);
19153 }
19154
19155 /* Allocate memory for states auxilliary information */
19156 {
19157 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
19158 (sizeof(struct _ssStatesInfo2));
19159 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
19160 malloc(sizeof(ssPeriodicStatesInfo));
19161 ss_VALIDATE_MEMORY(rts,statesInfo2);
19162 ssSetStatesInfo2(childS, statesInfo2);
19163 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
19164 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
19165 }
19166
19167 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
19168 RegNumInputPorts);
19169 ssSetRegNumInputPortsFcnArg(childS,childS);
19170
19171 /* inputs */
19172 {
19173 struct _ssPortInputs *inputPortInfo =
19174 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
19175 ss_VALIDATE_MEMORY(rts,inputPortInfo);
19176 _ssSetNumInputPorts(childS, 3);
19177 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
19178
19179 /* port 0 */
19180 {
19181 real32_T const **sfcnUPtrs = (real32_T const **)
19182 malloc(1 * sizeof(real32_T *));
19183 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
19184 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
19185 ssGetLocalBlockIO(rts))->Divide_l;
19186 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
19187 _ssSetInputPortNumDimensions(childS, 0, 1);
19188 ssSetInputPortWidth(childS, 0, 1);
19189 }
19190
19191 /* port 1 */
19192 {
19193 real32_T const **sfcnUPtrs = (real32_T const **)
19194 malloc(1 * sizeof(real32_T *));
19195 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
19196 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
19197 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
19198 _ssSetInputPortNumDimensions(childS, 1, 1);
19199 ssSetInputPortWidth(childS, 1, 1);
19200 }
19201
19202 /* port 2 */
19203 {
19204 real32_T const **sfcnUPtrs = (real32_T const **)
19205 malloc(1 * sizeof(real32_T *));
19206 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
19207 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;
19208 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
19209 _ssSetInputPortNumDimensions(childS, 2, 1);
19210 ssSetInputPortWidth(childS, 2, 1);
19211 }
19212 }
19213
19214 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
19215 RegNumOutputPorts);
19216 ssSetRegNumOutputPortsFcnArg(childS,childS);
19217
19218 /* outputs */
19219 {
19220 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
19221 calloc(1, sizeof(struct _ssPortOutputs));
19222 ss_VALIDATE_MEMORY(rts,outputPortInfo);
19223 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
19224 _ssSetNumOutputPorts(childS, 1);
19225
19226 /* port 0 */
19227 {
19228 _ssSetOutputPortNumDimensions(childS, 0, 1);
19229 ssSetOutputPortWidth(childS, 0, 1);
19230 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
19231 ssGetLocalBlockIO(rts))->GeneratedSFunction1_p));
19232 }
19233 }
19234
19235 /* path info */
19236 _ssSetModelName(childS, "SaturationLimiter_sf");
19237 _ssSetPath(childS,
19238 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Saturation Limiter2/Generated S-Function1");
19239 if (ssGetRTModel(rts) == (NULL)) {
19240 _ssSetParentSS(childS, rts);
19241 _ssSetRootSS(childS, ssGetRootSS(rts));
19242 } else {
19243 ssSetRTModel(childS,ssGetRTModel(rts));
19244 _ssSetParentSS(childS, (NULL));
19245 _ssSetRootSS(childS, childS);
19246 }
19247
19248 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
19249 (childS)->regDataType.arg1 = ((void *)(childS));
19250 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
19251 FcnSetErrorStatus);
19252 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
19253 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
19254 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
19255 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
19256
19257 /* registration */
19258#if defined(MATLAB_MEX_FILE)
19259
19260 {
19261 int_T i;
19262 mxArray *plhs[1];
19263 mxArray *prhs[4];
19264 double *pr;
19265 volatile int_T *intS = (int_T *)&childS;
19266 int_T addrlen = sizeof(SimStruct *);
19267 int_T m = addrlen/sizeof(int_T) + 1;
19268 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
19269 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
19270 pr = mxGetPr(prhs[1]);
19271 for (i = 0; i < m - 1; i++) {
19272 pr[i] = (double)intS[i];
19273 }
19274
19275 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
19276 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
19277 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
19278
19279 /* Reset port dimensions info functions because the S-function
19280 * and accelerator mex-files explicitly set their dimensions,
19281 * i.e., they are not dynamically sized. For this case, the
19282 * mex-file is responsible for the dimensions info memory
19283 * and Simulink should not free it. This is achieved by
19284 * setting the following two methods to NULL.
19285 */
19286 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
19287 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
19288
19289 /*
19290 * Setup function pointers and call mdlInitializeSizes via
19291 * simulink.c
19292 */
19293 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
19294 mxDestroyArray(plhs[0]);
19295 mxDestroyArray(prhs[0]);
19296 mxDestroyArray(prhs[1]);
19297 mxDestroyArray(prhs[2]);
19298 mxDestroyArray(prhs[3]);
19299 }
19300
19301#else
19302
19303 {
19304 SaturationLimiter_sf(childS);
19305 sfcnInitializeSizes(childS);
19306 }
19307
19308#endif
19309
19310 sfcnInitializeSampleTimes(childS);
19311
19312 /* adjust sample time */
19313 ssSetSampleTime(childS, 0, 0.005);
19314 ssSetOffsetTime(childS, 0, 0.0);
19315 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];
19316
19317 /* set compiled values of dynamic vector attributes */
19318 ssSetNumNonsampledZCs(childS, 0);
19319
19320 /* Update connectivity flags for each port */
19321 _ssSetInputPortConnected(childS, 0, 1);
19322 _ssSetInputPortConnected(childS, 1, 1);
19323 _ssSetInputPortConnected(childS, 2, 1);
19324 _ssSetOutputPortConnected(childS, 0, 1);
19325 _ssSetOutputPortBeingMerged(childS, 0, 0);
19326
19327 /* Update the BufferDstPort flags for each input port */
19328 _ssSetInputPortBufferDstPort(childS, 0, -1);
19329 _ssSetInputPortBufferDstPort(childS, 1, -1);
19330 _ssSetInputPortBufferDstPort(childS, 2, -1);
19331 }
19332
19333 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S127>/Generated S-Function6 (Res180_sf) */
19334 {
19335 SimStruct *childS = ssGetSFunction(rts, 72);
19336
19337 /* timing info */
19338 time_T *sfcnPeriod;
19339 time_T *sfcnOffset;
19340 int_T *sfcnTsMap;
19341 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
19342 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
19343 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
19344 ss_VALIDATE_MEMORY(rts,sfcnOffset);
19345 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
19346 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
19347 (void) memset((void*)sfcnPeriod, 0,
19348 sizeof(time_T)*1);
19349 (void) memset((void*)sfcnOffset, 0,
19350 sizeof(time_T)*1);
19351 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
19352 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
19353 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
19354
19355 /* Set up the mdlInfo pointer */
19356# ifdef USE_RTMODEL
19357
19358 {
19359 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
19360 struct _ssBlkInfo2));
19361 ss_VALIDATE_MEMORY(rts,blkInfo2);
19362 ssSetBlkInfo2Ptr(childS, blkInfo2);
19363 }
19364
19365 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
19366
19367# else
19368
19369 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
19370
19371# endif /* USE_RTMODEL */
19372
19373 /* Allocate memory of model methods 2 */
19374 {
19375 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
19376 malloc(sizeof(struct _ssSFcnModelMethods2));
19377 ss_VALIDATE_MEMORY(rts,methods2);
19378 ssSetModelMethods2(childS, methods2);
19379 }
19380
19381 /* Allocate memory of model methods 3 */
19382 {
19383 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
19384 malloc(sizeof(struct _ssSFcnModelMethods3));
19385 ss_VALIDATE_MEMORY(rts,methods3);
19386 ssSetModelMethods3(childS, methods3);
19387 }
19388
19389 /* Allocate memory for states auxilliary information */
19390 {
19391 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
19392 (sizeof(struct _ssStatesInfo2));
19393 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
19394 malloc(sizeof(ssPeriodicStatesInfo));
19395 ss_VALIDATE_MEMORY(rts,statesInfo2);
19396 ssSetStatesInfo2(childS, statesInfo2);
19397 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
19398 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
19399 }
19400
19401 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
19402 RegNumInputPorts);
19403 ssSetRegNumInputPortsFcnArg(childS,childS);
19404
19405 /* inputs */
19406 {
19407 struct _ssPortInputs *inputPortInfo =
19408 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
19409 ss_VALIDATE_MEMORY(rts,inputPortInfo);
19410 _ssSetNumInputPorts(childS, 1);
19411 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
19412
19413 /* port 0 */
19414 {
19415 real32_T const **sfcnUPtrs = (real32_T const **)
19416 malloc(1 * sizeof(real32_T *));
19417 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
19418 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
19419 ssGetLocalBlockIO(rts))->Sum3_c;
19420 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
19421 _ssSetInputPortNumDimensions(childS, 0, 1);
19422 ssSetInputPortWidth(childS, 0, 1);
19423 }
19424 }
19425
19426 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
19427 RegNumOutputPorts);
19428 ssSetRegNumOutputPortsFcnArg(childS,childS);
19429
19430 /* outputs */
19431 {
19432 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
19433 calloc(1, sizeof(struct _ssPortOutputs));
19434 ss_VALIDATE_MEMORY(rts,outputPortInfo);
19435 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
19436 _ssSetNumOutputPorts(childS, 1);
19437
19438 /* port 0 */
19439 {
19440 _ssSetOutputPortNumDimensions(childS, 0, 1);
19441 ssSetOutputPortWidth(childS, 0, 1);
19442 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
19443 ssGetLocalBlockIO(rts))->GeneratedSFunction6_a));
19444 }
19445 }
19446
19447 /* path info */
19448 _ssSetModelName(childS, "Res180_sf");
19449 _ssSetPath(childS,
19450 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Generated S-Function6");
19451 if (ssGetRTModel(rts) == (NULL)) {
19452 _ssSetParentSS(childS, rts);
19453 _ssSetRootSS(childS, ssGetRootSS(rts));
19454 } else {
19455 ssSetRTModel(childS,ssGetRTModel(rts));
19456 _ssSetParentSS(childS, (NULL));
19457 _ssSetRootSS(childS, childS);
19458 }
19459
19460 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
19461 (childS)->regDataType.arg1 = ((void *)(childS));
19462 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
19463 FcnSetErrorStatus);
19464 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
19465 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
19466 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
19467 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
19468
19469 /* registration */
19470#if defined(MATLAB_MEX_FILE)
19471
19472 {
19473 int_T i;
19474 mxArray *plhs[1];
19475 mxArray *prhs[4];
19476 double *pr;
19477 volatile int_T *intS = (int_T *)&childS;
19478 int_T addrlen = sizeof(SimStruct *);
19479 int_T m = addrlen/sizeof(int_T) + 1;
19480 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
19481 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
19482 pr = mxGetPr(prhs[1]);
19483 for (i = 0; i < m - 1; i++) {
19484 pr[i] = (double)intS[i];
19485 }
19486
19487 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
19488 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
19489 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
19490
19491 /* Reset port dimensions info functions because the S-function
19492 * and accelerator mex-files explicitly set their dimensions,
19493 * i.e., they are not dynamically sized. For this case, the
19494 * mex-file is responsible for the dimensions info memory
19495 * and Simulink should not free it. This is achieved by
19496 * setting the following two methods to NULL.
19497 */
19498 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
19499 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
19500
19501 /*
19502 * Setup function pointers and call mdlInitializeSizes via
19503 * simulink.c
19504 */
19505 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
19506 mxDestroyArray(plhs[0]);
19507 mxDestroyArray(prhs[0]);
19508 mxDestroyArray(prhs[1]);
19509 mxDestroyArray(prhs[2]);
19510 mxDestroyArray(prhs[3]);
19511 }
19512
19513#else
19514
19515 {
19516 Res180_sf(childS);
19517 sfcnInitializeSizes(childS);
19518 }
19519
19520#endif
19521
19522 sfcnInitializeSampleTimes(childS);
19523
19524 /* adjust sample time */
19525 ssSetSampleTime(childS, 0, 0.0);
19526 ssSetOffsetTime(childS, 0, 0.0);
19527 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
19528
19529 /* set compiled values of dynamic vector attributes */
19530 ssSetNumNonsampledZCs(childS, 0);
19531
19532 /* Update connectivity flags for each port */
19533 _ssSetInputPortConnected(childS, 0, 1);
19534 _ssSetOutputPortConnected(childS, 0, 1);
19535 _ssSetOutputPortBeingMerged(childS, 0, 0);
19536
19537 /* Update the BufferDstPort flags for each input port */
19538 _ssSetInputPortBufferDstPort(childS, 0, -1);
19539 }
19540
19541 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S144>/Generated S-Function1 (SaturationLimiter_sf) */
19542 {
19543 SimStruct *childS = ssGetSFunction(rts, 73);
19544
19545 /* timing info */
19546 time_T *sfcnPeriod;
19547 time_T *sfcnOffset;
19548 int_T *sfcnTsMap;
19549 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
19550 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
19551 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
19552 ss_VALIDATE_MEMORY(rts,sfcnOffset);
19553 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
19554 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
19555 (void) memset((void*)sfcnPeriod, 0,
19556 sizeof(time_T)*1);
19557 (void) memset((void*)sfcnOffset, 0,
19558 sizeof(time_T)*1);
19559 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
19560 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
19561 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
19562
19563 /* Set up the mdlInfo pointer */
19564# ifdef USE_RTMODEL
19565
19566 {
19567 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
19568 struct _ssBlkInfo2));
19569 ss_VALIDATE_MEMORY(rts,blkInfo2);
19570 ssSetBlkInfo2Ptr(childS, blkInfo2);
19571 }
19572
19573 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
19574
19575# else
19576
19577 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
19578
19579# endif /* USE_RTMODEL */
19580
19581 /* Allocate memory of model methods 2 */
19582 {
19583 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
19584 malloc(sizeof(struct _ssSFcnModelMethods2));
19585 ss_VALIDATE_MEMORY(rts,methods2);
19586 ssSetModelMethods2(childS, methods2);
19587 }
19588
19589 /* Allocate memory of model methods 3 */
19590 {
19591 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
19592 malloc(sizeof(struct _ssSFcnModelMethods3));
19593 ss_VALIDATE_MEMORY(rts,methods3);
19594 ssSetModelMethods3(childS, methods3);
19595 }
19596
19597 /* Allocate memory for states auxilliary information */
19598 {
19599 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
19600 (sizeof(struct _ssStatesInfo2));
19601 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
19602 malloc(sizeof(ssPeriodicStatesInfo));
19603 ss_VALIDATE_MEMORY(rts,statesInfo2);
19604 ssSetStatesInfo2(childS, statesInfo2);
19605 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
19606 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
19607 }
19608
19609 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
19610 RegNumInputPorts);
19611 ssSetRegNumInputPortsFcnArg(childS,childS);
19612
19613 /* inputs */
19614 {
19615 struct _ssPortInputs *inputPortInfo =
19616 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
19617 ss_VALIDATE_MEMORY(rts,inputPortInfo);
19618 _ssSetNumInputPorts(childS, 3);
19619 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
19620
19621 /* port 0 */
19622 {
19623 real32_T const **sfcnUPtrs = (real32_T const **)
19624 malloc(1 * sizeof(real32_T *));
19625 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
19626 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
19627 ssGetLocalBlockIO(rts))->GeneratedSFunction6_a;
19628 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
19629 _ssSetInputPortNumDimensions(childS, 0, 1);
19630 ssSetInputPortWidth(childS, 0, 1);
19631 }
19632
19633 /* port 1 */
19634 {
19635 real32_T const **sfcnUPtrs = (real32_T const **)
19636 malloc(1 * sizeof(real32_T *));
19637 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
19638 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
19639 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
19640 _ssSetInputPortNumDimensions(childS, 1, 1);
19641 ssSetInputPortWidth(childS, 1, 1);
19642 }
19643
19644 /* port 2 */
19645 {
19646 real32_T const **sfcnUPtrs = (real32_T const **)
19647 malloc(1 * sizeof(real32_T *));
19648 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
19649 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;
19650 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
19651 _ssSetInputPortNumDimensions(childS, 2, 1);
19652 ssSetInputPortWidth(childS, 2, 1);
19653 }
19654 }
19655
19656 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
19657 RegNumOutputPorts);
19658 ssSetRegNumOutputPortsFcnArg(childS,childS);
19659
19660 /* outputs */
19661 {
19662 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
19663 calloc(1, sizeof(struct _ssPortOutputs));
19664 ss_VALIDATE_MEMORY(rts,outputPortInfo);
19665 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
19666 _ssSetNumOutputPorts(childS, 1);
19667
19668 /* port 0 */
19669 {
19670 _ssSetOutputPortNumDimensions(childS, 0, 1);
19671 ssSetOutputPortWidth(childS, 0, 1);
19672 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
19673 ssGetLocalBlockIO(rts))->GeneratedSFunction1_l1));
19674 }
19675 }
19676
19677 /* path info */
19678 _ssSetModelName(childS, "SaturationLimiter_sf");
19679 _ssSetPath(childS,
19680 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Saturation Limiter1/Generated S-Function1");
19681 if (ssGetRTModel(rts) == (NULL)) {
19682 _ssSetParentSS(childS, rts);
19683 _ssSetRootSS(childS, ssGetRootSS(rts));
19684 } else {
19685 ssSetRTModel(childS,ssGetRTModel(rts));
19686 _ssSetParentSS(childS, (NULL));
19687 _ssSetRootSS(childS, childS);
19688 }
19689
19690 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
19691 (childS)->regDataType.arg1 = ((void *)(childS));
19692 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
19693 FcnSetErrorStatus);
19694 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
19695 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
19696 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
19697 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
19698
19699 /* registration */
19700#if defined(MATLAB_MEX_FILE)
19701
19702 {
19703 int_T i;
19704 mxArray *plhs[1];
19705 mxArray *prhs[4];
19706 double *pr;
19707 volatile int_T *intS = (int_T *)&childS;
19708 int_T addrlen = sizeof(SimStruct *);
19709 int_T m = addrlen/sizeof(int_T) + 1;
19710 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
19711 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
19712 pr = mxGetPr(prhs[1]);
19713 for (i = 0; i < m - 1; i++) {
19714 pr[i] = (double)intS[i];
19715 }
19716
19717 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
19718 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
19719 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
19720
19721 /* Reset port dimensions info functions because the S-function
19722 * and accelerator mex-files explicitly set their dimensions,
19723 * i.e., they are not dynamically sized. For this case, the
19724 * mex-file is responsible for the dimensions info memory
19725 * and Simulink should not free it. This is achieved by
19726 * setting the following two methods to NULL.
19727 */
19728 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
19729 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
19730
19731 /*
19732 * Setup function pointers and call mdlInitializeSizes via
19733 * simulink.c
19734 */
19735 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
19736 mxDestroyArray(plhs[0]);
19737 mxDestroyArray(prhs[0]);
19738 mxDestroyArray(prhs[1]);
19739 mxDestroyArray(prhs[2]);
19740 mxDestroyArray(prhs[3]);
19741 }
19742
19743#else
19744
19745 {
19746 SaturationLimiter_sf(childS);
19747 sfcnInitializeSizes(childS);
19748 }
19749
19750#endif
19751
19752 sfcnInitializeSampleTimes(childS);
19753
19754 /* adjust sample time */
19755 ssSetSampleTime(childS, 0, 0.0);
19756 ssSetOffsetTime(childS, 0, 0.0);
19757 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
19758
19759 /* set compiled values of dynamic vector attributes */
19760 ssSetNumNonsampledZCs(childS, 0);
19761
19762 /* Update connectivity flags for each port */
19763 _ssSetInputPortConnected(childS, 0, 1);
19764 _ssSetInputPortConnected(childS, 1, 1);
19765 _ssSetInputPortConnected(childS, 2, 1);
19766 _ssSetOutputPortConnected(childS, 0, 1);
19767 _ssSetOutputPortBeingMerged(childS, 0, 0);
19768
19769 /* Update the BufferDstPort flags for each input port */
19770 _ssSetInputPortBufferDstPort(childS, 0, -1);
19771 _ssSetInputPortBufferDstPort(childS, 1, -1);
19772 _ssSetInputPortBufferDstPort(childS, 2, -1);
19773 }
19774
19775 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S148>/Generated S-Function (Gain_sf) */
19776 {
19777 SimStruct *childS = ssGetSFunction(rts, 74);
19778
19779 /* timing info */
19780 time_T *sfcnPeriod;
19781 time_T *sfcnOffset;
19782 int_T *sfcnTsMap;
19783 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
19784 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
19785 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
19786 ss_VALIDATE_MEMORY(rts,sfcnOffset);
19787 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
19788 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
19789 (void) memset((void*)sfcnPeriod, 0,
19790 sizeof(time_T)*1);
19791 (void) memset((void*)sfcnOffset, 0,
19792 sizeof(time_T)*1);
19793 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
19794 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
19795 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
19796
19797 /* Set up the mdlInfo pointer */
19798# ifdef USE_RTMODEL
19799
19800 {
19801 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
19802 struct _ssBlkInfo2));
19803 ss_VALIDATE_MEMORY(rts,blkInfo2);
19804 ssSetBlkInfo2Ptr(childS, blkInfo2);
19805 }
19806
19807 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
19808
19809# else
19810
19811 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
19812
19813# endif /* USE_RTMODEL */
19814
19815 /* Allocate memory of model methods 2 */
19816 {
19817 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
19818 malloc(sizeof(struct _ssSFcnModelMethods2));
19819 ss_VALIDATE_MEMORY(rts,methods2);
19820 ssSetModelMethods2(childS, methods2);
19821 }
19822
19823 /* Allocate memory of model methods 3 */
19824 {
19825 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
19826 malloc(sizeof(struct _ssSFcnModelMethods3));
19827 ss_VALIDATE_MEMORY(rts,methods3);
19828 ssSetModelMethods3(childS, methods3);
19829 }
19830
19831 /* Allocate memory for states auxilliary information */
19832 {
19833 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
19834 (sizeof(struct _ssStatesInfo2));
19835 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
19836 malloc(sizeof(ssPeriodicStatesInfo));
19837 ss_VALIDATE_MEMORY(rts,statesInfo2);
19838 ssSetStatesInfo2(childS, statesInfo2);
19839 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
19840 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
19841 }
19842
19843 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
19844 RegNumInputPorts);
19845 ssSetRegNumInputPortsFcnArg(childS,childS);
19846
19847 /* inputs */
19848 {
19849 struct _ssPortInputs *inputPortInfo =
19850 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
19851 ss_VALIDATE_MEMORY(rts,inputPortInfo);
19852 _ssSetNumInputPorts(childS, 2);
19853 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
19854
19855 /* port 0 */
19856 {
19857 real32_T const **sfcnUPtrs = (real32_T const **)
19858 malloc(1 * sizeof(real32_T *));
19859 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
19860 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
19861 ssGetLocalBlockIO(rts))->GeneratedSFunction1_l1;
19862 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
19863 _ssSetInputPortNumDimensions(childS, 0, 1);
19864 ssSetInputPortWidth(childS, 0, 1);
19865 }
19866
19867 /* port 1 */
19868 {
19869 real32_T const **sfcnUPtrs = (real32_T const **)
19870 malloc(1 * sizeof(real32_T *));
19871 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
19872 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
19873 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
19874 _ssSetInputPortNumDimensions(childS, 1, 1);
19875 ssSetInputPortWidth(childS, 1, 1);
19876 }
19877 }
19878
19879 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
19880 RegNumOutputPorts);
19881 ssSetRegNumOutputPortsFcnArg(childS,childS);
19882
19883 /* outputs */
19884 {
19885 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
19886 calloc(1, sizeof(struct _ssPortOutputs));
19887 ss_VALIDATE_MEMORY(rts,outputPortInfo);
19888 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
19889 _ssSetNumOutputPorts(childS, 1);
19890
19891 /* port 0 */
19892 {
19893 _ssSetOutputPortNumDimensions(childS, 0, 1);
19894 ssSetOutputPortWidth(childS, 0, 1);
19895 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
19896 ssGetLocalBlockIO(rts))->GeneratedSFunction_cv));
19897 }
19898 }
19899
19900 /* path info */
19901 _ssSetModelName(childS, "Gain_sf");
19902 _ssSetPath(childS,
19903 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/gain2/Generated S-Function");
19904 if (ssGetRTModel(rts) == (NULL)) {
19905 _ssSetParentSS(childS, rts);
19906 _ssSetRootSS(childS, ssGetRootSS(rts));
19907 } else {
19908 ssSetRTModel(childS,ssGetRTModel(rts));
19909 _ssSetParentSS(childS, (NULL));
19910 _ssSetRootSS(childS, childS);
19911 }
19912
19913 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
19914 (childS)->regDataType.arg1 = ((void *)(childS));
19915 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
19916 FcnSetErrorStatus);
19917 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
19918 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
19919 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
19920 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
19921
19922 /* registration */
19923#if defined(MATLAB_MEX_FILE)
19924
19925 {
19926 int_T i;
19927 mxArray *plhs[1];
19928 mxArray *prhs[4];
19929 double *pr;
19930 volatile int_T *intS = (int_T *)&childS;
19931 int_T addrlen = sizeof(SimStruct *);
19932 int_T m = addrlen/sizeof(int_T) + 1;
19933 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
19934 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
19935 pr = mxGetPr(prhs[1]);
19936 for (i = 0; i < m - 1; i++) {
19937 pr[i] = (double)intS[i];
19938 }
19939
19940 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
19941 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
19942 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
19943
19944 /* Reset port dimensions info functions because the S-function
19945 * and accelerator mex-files explicitly set their dimensions,
19946 * i.e., they are not dynamically sized. For this case, the
19947 * mex-file is responsible for the dimensions info memory
19948 * and Simulink should not free it. This is achieved by
19949 * setting the following two methods to NULL.
19950 */
19951 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
19952 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
19953
19954 /*
19955 * Setup function pointers and call mdlInitializeSizes via
19956 * simulink.c
19957 */
19958 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
19959 mxDestroyArray(plhs[0]);
19960 mxDestroyArray(prhs[0]);
19961 mxDestroyArray(prhs[1]);
19962 mxDestroyArray(prhs[2]);
19963 mxDestroyArray(prhs[3]);
19964 }
19965
19966#else
19967
19968 {
19969 Gain_sf(childS);
19970 sfcnInitializeSizes(childS);
19971 }
19972
19973#endif
19974
19975 sfcnInitializeSampleTimes(childS);
19976
19977 /* adjust sample time */
19978 ssSetSampleTime(childS, 0, 0.0);
19979 ssSetOffsetTime(childS, 0, 0.0);
19980 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
19981
19982 /* set compiled values of dynamic vector attributes */
19983 ssSetNumNonsampledZCs(childS, 0);
19984
19985 /* Update connectivity flags for each port */
19986 _ssSetInputPortConnected(childS, 0, 1);
19987 _ssSetInputPortConnected(childS, 1, 1);
19988 _ssSetOutputPortConnected(childS, 0, 1);
19989 _ssSetOutputPortBeingMerged(childS, 0, 0);
19990
19991 /* Update the BufferDstPort flags for each input port */
19992 _ssSetInputPortBufferDstPort(childS, 0, -1);
19993 _ssSetInputPortBufferDstPort(childS, 1, -1);
19994 }
19995
19996 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S142>/Generated S-Function2 (LeadLagFilter_sf) */
19997 {
19998 SimStruct *childS = ssGetSFunction(rts, 75);
19999
20000 /* timing info */
20001 time_T *sfcnPeriod;
20002 time_T *sfcnOffset;
20003 int_T *sfcnTsMap;
20004 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
20005 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
20006 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
20007 ss_VALIDATE_MEMORY(rts,sfcnOffset);
20008 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
20009 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
20010 (void) memset((void*)sfcnPeriod, 0,
20011 sizeof(time_T)*1);
20012 (void) memset((void*)sfcnOffset, 0,
20013 sizeof(time_T)*1);
20014 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
20015 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
20016 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
20017
20018 /* Set up the mdlInfo pointer */
20019# ifdef USE_RTMODEL
20020
20021 {
20022 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
20023 struct _ssBlkInfo2));
20024 ss_VALIDATE_MEMORY(rts,blkInfo2);
20025 ssSetBlkInfo2Ptr(childS, blkInfo2);
20026 }
20027
20028 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
20029
20030# else
20031
20032 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
20033
20034# endif /* USE_RTMODEL */
20035
20036 /* Allocate memory of model methods 2 */
20037 {
20038 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
20039 malloc(sizeof(struct _ssSFcnModelMethods2));
20040 ss_VALIDATE_MEMORY(rts,methods2);
20041 ssSetModelMethods2(childS, methods2);
20042 }
20043
20044 /* Allocate memory of model methods 3 */
20045 {
20046 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
20047 malloc(sizeof(struct _ssSFcnModelMethods3));
20048 ss_VALIDATE_MEMORY(rts,methods3);
20049 ssSetModelMethods3(childS, methods3);
20050 }
20051
20052 /* Allocate memory for states auxilliary information */
20053 {
20054 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
20055 (sizeof(struct _ssStatesInfo2));
20056 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
20057 malloc(sizeof(ssPeriodicStatesInfo));
20058 ss_VALIDATE_MEMORY(rts,statesInfo2);
20059 ssSetStatesInfo2(childS, statesInfo2);
20060 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
20061 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
20062 }
20063
20064 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
20065 RegNumInputPorts);
20066 ssSetRegNumInputPortsFcnArg(childS,childS);
20067
20068 /* inputs */
20069 {
20070 struct _ssPortInputs *inputPortInfo =
20071 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
20072 ss_VALIDATE_MEMORY(rts,inputPortInfo);
20073 _ssSetNumInputPorts(childS, 7);
20074 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
20075
20076 /* port 0 */
20077 {
20078 real32_T const **sfcnUPtrs = (real32_T const **)
20079 malloc(1 * sizeof(real32_T *));
20080 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20081 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
20082 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
20083 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
20084 _ssSetInputPortNumDimensions(childS, 0, 1);
20085 ssSetInputPortWidth(childS, 0, 1);
20086 }
20087
20088 /* port 1 */
20089 {
20090 int8_T const **sfcnUPtrs = (int8_T const **)
20091 malloc(1 * sizeof(int8_T *));
20092 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20093 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
20094 ssGetLocalBlockIO(rts))->DataTypeConversion2_p;
20095 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
20096 _ssSetInputPortNumDimensions(childS, 1, 1);
20097 ssSetInputPortWidth(childS, 1, 1);
20098 }
20099
20100 /* port 2 */
20101 {
20102 real32_T const **sfcnUPtrs = (real32_T const **)
20103 malloc(1 * sizeof(real32_T *));
20104 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20105 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
20106 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
20107 _ssSetInputPortNumDimensions(childS, 2, 1);
20108 ssSetInputPortWidth(childS, 2, 1);
20109 }
20110
20111 /* port 3 */
20112 {
20113 real32_T const **sfcnUPtrs = (real32_T const **)
20114 malloc(1 * sizeof(real32_T *));
20115 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20116 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
20117 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
20118 _ssSetInputPortNumDimensions(childS, 3, 1);
20119 ssSetInputPortWidth(childS, 3, 1);
20120 }
20121
20122 /* port 4 */
20123 {
20124 real32_T const **sfcnUPtrs = (real32_T const **)
20125 malloc(1 * sizeof(real32_T *));
20126 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20127 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
20128 ssGetLocalBlockIO(rts))->Sum4_i;
20129 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
20130 _ssSetInputPortNumDimensions(childS, 4, 1);
20131 ssSetInputPortWidth(childS, 4, 1);
20132 }
20133
20134 /* port 5 */
20135 {
20136 real32_T const **sfcnUPtrs = (real32_T const **)
20137 malloc(1 * sizeof(real32_T *));
20138 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20139 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
20140 ssGetLocalBlockIO(rts))->Sum4_i;
20141 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
20142 _ssSetInputPortNumDimensions(childS, 5, 1);
20143 ssSetInputPortWidth(childS, 5, 1);
20144 }
20145
20146 /* port 6 */
20147 {
20148 real32_T const **sfcnUPtrs = (real32_T const **)
20149 malloc(1 * sizeof(real32_T *));
20150 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20151 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
20152 ssGetLocalBlockIO(rts))->GeneratedSFunction_cv;
20153 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
20154 _ssSetInputPortNumDimensions(childS, 6, 1);
20155 ssSetInputPortWidth(childS, 6, 1);
20156 }
20157 }
20158
20159 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
20160 RegNumOutputPorts);
20161 ssSetRegNumOutputPortsFcnArg(childS,childS);
20162
20163 /* outputs */
20164 {
20165 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
20166 calloc(1, sizeof(struct _ssPortOutputs));
20167 ss_VALIDATE_MEMORY(rts,outputPortInfo);
20168 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
20169 _ssSetNumOutputPorts(childS, 1);
20170
20171 /* port 0 */
20172 {
20173 _ssSetOutputPortNumDimensions(childS, 0, 1);
20174 ssSetOutputPortWidth(childS, 0, 1);
20175 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
20176 ssGetLocalBlockIO(rts))->GeneratedSFunction2_c));
20177 }
20178 }
20179
20180 /* path info */
20181 _ssSetModelName(childS, "LeadLagFilter_sf");
20182 _ssSetPath(childS,
20183 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Lead lag1/Generated S-Function2");
20184 if (ssGetRTModel(rts) == (NULL)) {
20185 _ssSetParentSS(childS, rts);
20186 _ssSetRootSS(childS, ssGetRootSS(rts));
20187 } else {
20188 ssSetRTModel(childS,ssGetRTModel(rts));
20189 _ssSetParentSS(childS, (NULL));
20190 _ssSetRootSS(childS, childS);
20191 }
20192
20193 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
20194
20195 /* work vectors */
20196 {
20197 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
20198 (4 * sizeof(struct _ssDWorkRecord));
20199 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
20200 calloc(4, sizeof(struct _ssDWorkAuxRecord));
20201 ss_VALIDATE_MEMORY(rts,dWorkRecord);
20202 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
20203 ssSetSFcnDWork(childS, dWorkRecord);
20204 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
20205 _ssSetNumDWork(childS, 4);
20206
20207 /* DWORK0 */
20208 ssSetDWorkWidth(childS, 0, 1);
20209 ssSetDWorkDataType(childS, 0,SS_SINGLE);
20210 ssSetDWorkComplexSignal(childS, 0, 0);
20211 ssSetDWorkUsedAsDState(childS, 0, 1);
20212 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 206))[0]);
20213
20214 /* DWORK1 */
20215 ssSetDWorkWidth(childS, 1, 1);
20216 ssSetDWorkDataType(childS, 1,SS_SINGLE);
20217 ssSetDWorkComplexSignal(childS, 1, 0);
20218 ssSetDWorkUsedAsDState(childS, 1, 1);
20219 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 207))[0]);
20220
20221 /* DWORK2 */
20222 ssSetDWorkWidth(childS, 2, 1);
20223 ssSetDWorkDataType(childS, 2,SS_INT8);
20224 ssSetDWorkComplexSignal(childS, 2, 0);
20225 ssSetDWorkUsedAsDState(childS, 2, 1);
20226 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 433))[0]);
20227
20228 /* DWORK3 */
20229 ssSetDWorkWidth(childS, 3, 1);
20230 ssSetDWorkDataType(childS, 3,SS_INT8);
20231 ssSetDWorkComplexSignal(childS, 3, 0);
20232 ssSetDWorkUsedAsDState(childS, 3, 1);
20233 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 434))[0]);
20234 }
20235
20236 (childS)->regDataType.arg1 = ((void *)(childS));
20237 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
20238 FcnSetErrorStatus);
20239 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
20240 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
20241 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
20242 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
20243
20244 /* registration */
20245#if defined(MATLAB_MEX_FILE)
20246
20247 {
20248 int_T i;
20249 mxArray *plhs[1];
20250 mxArray *prhs[4];
20251 double *pr;
20252 volatile int_T *intS = (int_T *)&childS;
20253 int_T addrlen = sizeof(SimStruct *);
20254 int_T m = addrlen/sizeof(int_T) + 1;
20255 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
20256 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
20257 pr = mxGetPr(prhs[1]);
20258 for (i = 0; i < m - 1; i++) {
20259 pr[i] = (double)intS[i];
20260 }
20261
20262 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
20263 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
20264 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
20265
20266 /* Reset port dimensions info functions because the S-function
20267 * and accelerator mex-files explicitly set their dimensions,
20268 * i.e., they are not dynamically sized. For this case, the
20269 * mex-file is responsible for the dimensions info memory
20270 * and Simulink should not free it. This is achieved by
20271 * setting the following two methods to NULL.
20272 */
20273 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
20274 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
20275
20276 /*
20277 * Setup function pointers and call mdlInitializeSizes via
20278 * simulink.c
20279 */
20280 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
20281 mxDestroyArray(plhs[0]);
20282 mxDestroyArray(prhs[0]);
20283 mxDestroyArray(prhs[1]);
20284 mxDestroyArray(prhs[2]);
20285 mxDestroyArray(prhs[3]);
20286 }
20287
20288#else
20289
20290 {
20291 LeadLagFilter_sf(childS);
20292 sfcnInitializeSizes(childS);
20293 }
20294
20295#endif
20296
20297 sfcnInitializeSampleTimes(childS);
20298
20299 /* adjust sample time */
20300 ssSetSampleTime(childS, 0, 0.0);
20301 ssSetOffsetTime(childS, 0, 0.0);
20302 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
20303
20304 /* set compiled values of dynamic vector attributes */
20305 ssSetNumNonsampledZCs(childS, 0);
20306
20307 /* Update connectivity flags for each port */
20308 _ssSetInputPortConnected(childS, 0, 1);
20309 _ssSetInputPortConnected(childS, 1, 1);
20310 _ssSetInputPortConnected(childS, 2, 1);
20311 _ssSetInputPortConnected(childS, 3, 1);
20312 _ssSetInputPortConnected(childS, 4, 1);
20313 _ssSetInputPortConnected(childS, 5, 1);
20314 _ssSetInputPortConnected(childS, 6, 1);
20315 _ssSetOutputPortConnected(childS, 0, 1);
20316 _ssSetOutputPortBeingMerged(childS, 0, 0);
20317
20318 /* Update the BufferDstPort flags for each input port */
20319 _ssSetInputPortBufferDstPort(childS, 0, -1);
20320 _ssSetInputPortBufferDstPort(childS, 1, -1);
20321 _ssSetInputPortBufferDstPort(childS, 2, -1);
20322 _ssSetInputPortBufferDstPort(childS, 3, -1);
20323 _ssSetInputPortBufferDstPort(childS, 4, -1);
20324 _ssSetInputPortBufferDstPort(childS, 5, -1);
20325 _ssSetInputPortBufferDstPort(childS, 6, -1);
20326 }
20327
20328 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S143>/Generated S-Function1 (SaturationLimiter_sf) */
20329 {
20330 SimStruct *childS = ssGetSFunction(rts, 76);
20331
20332 /* timing info */
20333 time_T *sfcnPeriod;
20334 time_T *sfcnOffset;
20335 int_T *sfcnTsMap;
20336 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
20337 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
20338 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
20339 ss_VALIDATE_MEMORY(rts,sfcnOffset);
20340 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
20341 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
20342 (void) memset((void*)sfcnPeriod, 0,
20343 sizeof(time_T)*1);
20344 (void) memset((void*)sfcnOffset, 0,
20345 sizeof(time_T)*1);
20346 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
20347 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
20348 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
20349
20350 /* Set up the mdlInfo pointer */
20351# ifdef USE_RTMODEL
20352
20353 {
20354 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
20355 struct _ssBlkInfo2));
20356 ss_VALIDATE_MEMORY(rts,blkInfo2);
20357 ssSetBlkInfo2Ptr(childS, blkInfo2);
20358 }
20359
20360 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
20361
20362# else
20363
20364 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
20365
20366# endif /* USE_RTMODEL */
20367
20368 /* Allocate memory of model methods 2 */
20369 {
20370 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
20371 malloc(sizeof(struct _ssSFcnModelMethods2));
20372 ss_VALIDATE_MEMORY(rts,methods2);
20373 ssSetModelMethods2(childS, methods2);
20374 }
20375
20376 /* Allocate memory of model methods 3 */
20377 {
20378 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
20379 malloc(sizeof(struct _ssSFcnModelMethods3));
20380 ss_VALIDATE_MEMORY(rts,methods3);
20381 ssSetModelMethods3(childS, methods3);
20382 }
20383
20384 /* Allocate memory for states auxilliary information */
20385 {
20386 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
20387 (sizeof(struct _ssStatesInfo2));
20388 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
20389 malloc(sizeof(ssPeriodicStatesInfo));
20390 ss_VALIDATE_MEMORY(rts,statesInfo2);
20391 ssSetStatesInfo2(childS, statesInfo2);
20392 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
20393 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
20394 }
20395
20396 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
20397 RegNumInputPorts);
20398 ssSetRegNumInputPortsFcnArg(childS,childS);
20399
20400 /* inputs */
20401 {
20402 struct _ssPortInputs *inputPortInfo =
20403 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
20404 ss_VALIDATE_MEMORY(rts,inputPortInfo);
20405 _ssSetNumInputPorts(childS, 3);
20406 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
20407
20408 /* port 0 */
20409 {
20410 real32_T const **sfcnUPtrs = (real32_T const **)
20411 malloc(1 * sizeof(real32_T *));
20412 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20413 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
20414 ssGetLocalBlockIO(rts))->GeneratedSFunction2_c;
20415 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
20416 _ssSetInputPortNumDimensions(childS, 0, 1);
20417 ssSetInputPortWidth(childS, 0, 1);
20418 }
20419
20420 /* port 1 */
20421 {
20422 real32_T const **sfcnUPtrs = (real32_T const **)
20423 malloc(1 * sizeof(real32_T *));
20424 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20425 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
20426 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
20427 _ssSetInputPortNumDimensions(childS, 1, 1);
20428 ssSetInputPortWidth(childS, 1, 1);
20429 }
20430
20431 /* port 2 */
20432 {
20433 real32_T const **sfcnUPtrs = (real32_T const **)
20434 malloc(1 * sizeof(real32_T *));
20435 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20436 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;
20437 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
20438 _ssSetInputPortNumDimensions(childS, 2, 1);
20439 ssSetInputPortWidth(childS, 2, 1);
20440 }
20441 }
20442
20443 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
20444 RegNumOutputPorts);
20445 ssSetRegNumOutputPortsFcnArg(childS,childS);
20446
20447 /* outputs */
20448 {
20449 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
20450 calloc(1, sizeof(struct _ssPortOutputs));
20451 ss_VALIDATE_MEMORY(rts,outputPortInfo);
20452 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
20453 _ssSetNumOutputPorts(childS, 1);
20454
20455 /* port 0 */
20456 {
20457 _ssSetOutputPortNumDimensions(childS, 0, 1);
20458 ssSetOutputPortWidth(childS, 0, 1);
20459 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
20460 ssGetLocalBlockIO(rts))->Saturation2_p));
20461 }
20462 }
20463
20464 /* path info */
20465 _ssSetModelName(childS, "SaturationLimiter_sf");
20466 _ssSetPath(childS,
20467 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Saturation Limiter/Generated S-Function1");
20468 if (ssGetRTModel(rts) == (NULL)) {
20469 _ssSetParentSS(childS, rts);
20470 _ssSetRootSS(childS, ssGetRootSS(rts));
20471 } else {
20472 ssSetRTModel(childS,ssGetRTModel(rts));
20473 _ssSetParentSS(childS, (NULL));
20474 _ssSetRootSS(childS, childS);
20475 }
20476
20477 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
20478 (childS)->regDataType.arg1 = ((void *)(childS));
20479 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
20480 FcnSetErrorStatus);
20481 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
20482 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
20483 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
20484 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
20485
20486 /* registration */
20487#if defined(MATLAB_MEX_FILE)
20488
20489 {
20490 int_T i;
20491 mxArray *plhs[1];
20492 mxArray *prhs[4];
20493 double *pr;
20494 volatile int_T *intS = (int_T *)&childS;
20495 int_T addrlen = sizeof(SimStruct *);
20496 int_T m = addrlen/sizeof(int_T) + 1;
20497 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
20498 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
20499 pr = mxGetPr(prhs[1]);
20500 for (i = 0; i < m - 1; i++) {
20501 pr[i] = (double)intS[i];
20502 }
20503
20504 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
20505 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
20506 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
20507
20508 /* Reset port dimensions info functions because the S-function
20509 * and accelerator mex-files explicitly set their dimensions,
20510 * i.e., they are not dynamically sized. For this case, the
20511 * mex-file is responsible for the dimensions info memory
20512 * and Simulink should not free it. This is achieved by
20513 * setting the following two methods to NULL.
20514 */
20515 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
20516 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
20517
20518 /*
20519 * Setup function pointers and call mdlInitializeSizes via
20520 * simulink.c
20521 */
20522 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
20523 mxDestroyArray(plhs[0]);
20524 mxDestroyArray(prhs[0]);
20525 mxDestroyArray(prhs[1]);
20526 mxDestroyArray(prhs[2]);
20527 mxDestroyArray(prhs[3]);
20528 }
20529
20530#else
20531
20532 {
20533 SaturationLimiter_sf(childS);
20534 sfcnInitializeSizes(childS);
20535 }
20536
20537#endif
20538
20539 sfcnInitializeSampleTimes(childS);
20540
20541 /* adjust sample time */
20542 ssSetSampleTime(childS, 0, 0.0);
20543 ssSetOffsetTime(childS, 0, 0.0);
20544 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
20545
20546 /* set compiled values of dynamic vector attributes */
20547 ssSetNumNonsampledZCs(childS, 0);
20548
20549 /* Update connectivity flags for each port */
20550 _ssSetInputPortConnected(childS, 0, 1);
20551 _ssSetInputPortConnected(childS, 1, 1);
20552 _ssSetInputPortConnected(childS, 2, 1);
20553 _ssSetOutputPortConnected(childS, 0, 1);
20554 _ssSetOutputPortBeingMerged(childS, 0, 0);
20555
20556 /* Update the BufferDstPort flags for each input port */
20557 _ssSetInputPortBufferDstPort(childS, 0, -1);
20558 _ssSetInputPortBufferDstPort(childS, 1, -1);
20559 _ssSetInputPortBufferDstPort(childS, 2, -1);
20560 }
20561
20562 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S127>/Generated S-Function1 (Res180_sf) */
20563 {
20564 SimStruct *childS = ssGetSFunction(rts, 77);
20565
20566 /* timing info */
20567 time_T *sfcnPeriod;
20568 time_T *sfcnOffset;
20569 int_T *sfcnTsMap;
20570 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
20571 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
20572 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
20573 ss_VALIDATE_MEMORY(rts,sfcnOffset);
20574 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
20575 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
20576 (void) memset((void*)sfcnPeriod, 0,
20577 sizeof(time_T)*1);
20578 (void) memset((void*)sfcnOffset, 0,
20579 sizeof(time_T)*1);
20580 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
20581 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
20582 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
20583
20584 /* Set up the mdlInfo pointer */
20585# ifdef USE_RTMODEL
20586
20587 {
20588 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
20589 struct _ssBlkInfo2));
20590 ss_VALIDATE_MEMORY(rts,blkInfo2);
20591 ssSetBlkInfo2Ptr(childS, blkInfo2);
20592 }
20593
20594 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
20595
20596# else
20597
20598 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
20599
20600# endif /* USE_RTMODEL */
20601
20602 /* Allocate memory of model methods 2 */
20603 {
20604 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
20605 malloc(sizeof(struct _ssSFcnModelMethods2));
20606 ss_VALIDATE_MEMORY(rts,methods2);
20607 ssSetModelMethods2(childS, methods2);
20608 }
20609
20610 /* Allocate memory of model methods 3 */
20611 {
20612 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
20613 malloc(sizeof(struct _ssSFcnModelMethods3));
20614 ss_VALIDATE_MEMORY(rts,methods3);
20615 ssSetModelMethods3(childS, methods3);
20616 }
20617
20618 /* Allocate memory for states auxilliary information */
20619 {
20620 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
20621 (sizeof(struct _ssStatesInfo2));
20622 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
20623 malloc(sizeof(ssPeriodicStatesInfo));
20624 ss_VALIDATE_MEMORY(rts,statesInfo2);
20625 ssSetStatesInfo2(childS, statesInfo2);
20626 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
20627 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
20628 }
20629
20630 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
20631 RegNumInputPorts);
20632 ssSetRegNumInputPortsFcnArg(childS,childS);
20633
20634 /* inputs */
20635 {
20636 struct _ssPortInputs *inputPortInfo =
20637 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
20638 ss_VALIDATE_MEMORY(rts,inputPortInfo);
20639 _ssSetNumInputPorts(childS, 1);
20640 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
20641
20642 /* port 0 */
20643 {
20644 real32_T const **sfcnUPtrs = (real32_T const **)
20645 malloc(1 * sizeof(real32_T *));
20646 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20647 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
20648 ssGetLocalBlockIO(rts))->Sum1_ga;
20649 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
20650 _ssSetInputPortNumDimensions(childS, 0, 1);
20651 ssSetInputPortWidth(childS, 0, 1);
20652 }
20653 }
20654
20655 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
20656 RegNumOutputPorts);
20657 ssSetRegNumOutputPortsFcnArg(childS,childS);
20658
20659 /* outputs */
20660 {
20661 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
20662 calloc(1, sizeof(struct _ssPortOutputs));
20663 ss_VALIDATE_MEMORY(rts,outputPortInfo);
20664 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
20665 _ssSetNumOutputPorts(childS, 1);
20666
20667 /* port 0 */
20668 {
20669 _ssSetOutputPortNumDimensions(childS, 0, 1);
20670 ssSetOutputPortWidth(childS, 0, 1);
20671 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
20672 ssGetLocalBlockIO(rts))->GeneratedSFunction1_bh));
20673 }
20674 }
20675
20676 /* path info */
20677 _ssSetModelName(childS, "Res180_sf");
20678 _ssSetPath(childS,
20679 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Generated S-Function1");
20680 if (ssGetRTModel(rts) == (NULL)) {
20681 _ssSetParentSS(childS, rts);
20682 _ssSetRootSS(childS, ssGetRootSS(rts));
20683 } else {
20684 ssSetRTModel(childS,ssGetRTModel(rts));
20685 _ssSetParentSS(childS, (NULL));
20686 _ssSetRootSS(childS, childS);
20687 }
20688
20689 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
20690 (childS)->regDataType.arg1 = ((void *)(childS));
20691 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
20692 FcnSetErrorStatus);
20693 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
20694 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
20695 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
20696 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
20697
20698 /* registration */
20699#if defined(MATLAB_MEX_FILE)
20700
20701 {
20702 int_T i;
20703 mxArray *plhs[1];
20704 mxArray *prhs[4];
20705 double *pr;
20706 volatile int_T *intS = (int_T *)&childS;
20707 int_T addrlen = sizeof(SimStruct *);
20708 int_T m = addrlen/sizeof(int_T) + 1;
20709 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
20710 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
20711 pr = mxGetPr(prhs[1]);
20712 for (i = 0; i < m - 1; i++) {
20713 pr[i] = (double)intS[i];
20714 }
20715
20716 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
20717 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
20718 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
20719
20720 /* Reset port dimensions info functions because the S-function
20721 * and accelerator mex-files explicitly set their dimensions,
20722 * i.e., they are not dynamically sized. For this case, the
20723 * mex-file is responsible for the dimensions info memory
20724 * and Simulink should not free it. This is achieved by
20725 * setting the following two methods to NULL.
20726 */
20727 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
20728 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
20729
20730 /*
20731 * Setup function pointers and call mdlInitializeSizes via
20732 * simulink.c
20733 */
20734 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
20735 mxDestroyArray(plhs[0]);
20736 mxDestroyArray(prhs[0]);
20737 mxDestroyArray(prhs[1]);
20738 mxDestroyArray(prhs[2]);
20739 mxDestroyArray(prhs[3]);
20740 }
20741
20742#else
20743
20744 {
20745 Res180_sf(childS);
20746 sfcnInitializeSizes(childS);
20747 }
20748
20749#endif
20750
20751 sfcnInitializeSampleTimes(childS);
20752
20753 /* adjust sample time */
20754 ssSetSampleTime(childS, 0, 0.0);
20755 ssSetOffsetTime(childS, 0, 0.0);
20756 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
20757
20758 /* set compiled values of dynamic vector attributes */
20759 ssSetNumNonsampledZCs(childS, 0);
20760
20761 /* Update connectivity flags for each port */
20762 _ssSetInputPortConnected(childS, 0, 1);
20763 _ssSetOutputPortConnected(childS, 0, 1);
20764 _ssSetOutputPortBeingMerged(childS, 0, 0);
20765
20766 /* Update the BufferDstPort flags for each input port */
20767 _ssSetInputPortBufferDstPort(childS, 0, -1);
20768 }
20769
20770 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S146>/Generated S-Function (Gain_sf) */
20771 {
20772 SimStruct *childS = ssGetSFunction(rts, 78);
20773
20774 /* timing info */
20775 time_T *sfcnPeriod;
20776 time_T *sfcnOffset;
20777 int_T *sfcnTsMap;
20778 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
20779 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
20780 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
20781 ss_VALIDATE_MEMORY(rts,sfcnOffset);
20782 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
20783 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
20784 (void) memset((void*)sfcnPeriod, 0,
20785 sizeof(time_T)*1);
20786 (void) memset((void*)sfcnOffset, 0,
20787 sizeof(time_T)*1);
20788 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
20789 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
20790 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
20791
20792 /* Set up the mdlInfo pointer */
20793# ifdef USE_RTMODEL
20794
20795 {
20796 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
20797 struct _ssBlkInfo2));
20798 ss_VALIDATE_MEMORY(rts,blkInfo2);
20799 ssSetBlkInfo2Ptr(childS, blkInfo2);
20800 }
20801
20802 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
20803
20804# else
20805
20806 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
20807
20808# endif /* USE_RTMODEL */
20809
20810 /* Allocate memory of model methods 2 */
20811 {
20812 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
20813 malloc(sizeof(struct _ssSFcnModelMethods2));
20814 ss_VALIDATE_MEMORY(rts,methods2);
20815 ssSetModelMethods2(childS, methods2);
20816 }
20817
20818 /* Allocate memory of model methods 3 */
20819 {
20820 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
20821 malloc(sizeof(struct _ssSFcnModelMethods3));
20822 ss_VALIDATE_MEMORY(rts,methods3);
20823 ssSetModelMethods3(childS, methods3);
20824 }
20825
20826 /* Allocate memory for states auxilliary information */
20827 {
20828 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
20829 (sizeof(struct _ssStatesInfo2));
20830 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
20831 malloc(sizeof(ssPeriodicStatesInfo));
20832 ss_VALIDATE_MEMORY(rts,statesInfo2);
20833 ssSetStatesInfo2(childS, statesInfo2);
20834 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
20835 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
20836 }
20837
20838 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
20839 RegNumInputPorts);
20840 ssSetRegNumInputPortsFcnArg(childS,childS);
20841
20842 /* inputs */
20843 {
20844 struct _ssPortInputs *inputPortInfo =
20845 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
20846 ss_VALIDATE_MEMORY(rts,inputPortInfo);
20847 _ssSetNumInputPorts(childS, 2);
20848 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
20849
20850 /* port 0 */
20851 {
20852 real32_T const **sfcnUPtrs = (real32_T const **)
20853 malloc(1 * sizeof(real32_T *));
20854 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20855 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
20856 ssGetLocalBlockIO(rts))->GeneratedSFunction1_bh;
20857 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
20858 _ssSetInputPortNumDimensions(childS, 0, 1);
20859 ssSetInputPortWidth(childS, 0, 1);
20860 }
20861
20862 /* port 1 */
20863 {
20864 real32_T const **sfcnUPtrs = (real32_T const **)
20865 malloc(1 * sizeof(real32_T *));
20866 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
20867 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
20868 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
20869 _ssSetInputPortNumDimensions(childS, 1, 1);
20870 ssSetInputPortWidth(childS, 1, 1);
20871 }
20872 }
20873
20874 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
20875 RegNumOutputPorts);
20876 ssSetRegNumOutputPortsFcnArg(childS,childS);
20877
20878 /* outputs */
20879 {
20880 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
20881 calloc(1, sizeof(struct _ssPortOutputs));
20882 ss_VALIDATE_MEMORY(rts,outputPortInfo);
20883 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
20884 _ssSetNumOutputPorts(childS, 1);
20885
20886 /* port 0 */
20887 {
20888 _ssSetOutputPortNumDimensions(childS, 0, 1);
20889 ssSetOutputPortWidth(childS, 0, 1);
20890 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
20891 ssGetLocalBlockIO(rts))->GeneratedSFunction_ma));
20892 }
20893 }
20894
20895 /* path info */
20896 _ssSetModelName(childS, "Gain_sf");
20897 _ssSetPath(childS,
20898 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/gain/Generated S-Function");
20899 if (ssGetRTModel(rts) == (NULL)) {
20900 _ssSetParentSS(childS, rts);
20901 _ssSetRootSS(childS, ssGetRootSS(rts));
20902 } else {
20903 ssSetRTModel(childS,ssGetRTModel(rts));
20904 _ssSetParentSS(childS, (NULL));
20905 _ssSetRootSS(childS, childS);
20906 }
20907
20908 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
20909 (childS)->regDataType.arg1 = ((void *)(childS));
20910 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
20911 FcnSetErrorStatus);
20912 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
20913 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
20914 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
20915 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
20916
20917 /* registration */
20918#if defined(MATLAB_MEX_FILE)
20919
20920 {
20921 int_T i;
20922 mxArray *plhs[1];
20923 mxArray *prhs[4];
20924 double *pr;
20925 volatile int_T *intS = (int_T *)&childS;
20926 int_T addrlen = sizeof(SimStruct *);
20927 int_T m = addrlen/sizeof(int_T) + 1;
20928 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
20929 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
20930 pr = mxGetPr(prhs[1]);
20931 for (i = 0; i < m - 1; i++) {
20932 pr[i] = (double)intS[i];
20933 }
20934
20935 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
20936 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
20937 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
20938
20939 /* Reset port dimensions info functions because the S-function
20940 * and accelerator mex-files explicitly set their dimensions,
20941 * i.e., they are not dynamically sized. For this case, the
20942 * mex-file is responsible for the dimensions info memory
20943 * and Simulink should not free it. This is achieved by
20944 * setting the following two methods to NULL.
20945 */
20946 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
20947 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
20948
20949 /*
20950 * Setup function pointers and call mdlInitializeSizes via
20951 * simulink.c
20952 */
20953 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
20954 mxDestroyArray(plhs[0]);
20955 mxDestroyArray(prhs[0]);
20956 mxDestroyArray(prhs[1]);
20957 mxDestroyArray(prhs[2]);
20958 mxDestroyArray(prhs[3]);
20959 }
20960
20961#else
20962
20963 {
20964 Gain_sf(childS);
20965 sfcnInitializeSizes(childS);
20966 }
20967
20968#endif
20969
20970 sfcnInitializeSampleTimes(childS);
20971
20972 /* adjust sample time */
20973 ssSetSampleTime(childS, 0, 0.0);
20974 ssSetOffsetTime(childS, 0, 0.0);
20975 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
20976
20977 /* set compiled values of dynamic vector attributes */
20978 ssSetNumNonsampledZCs(childS, 0);
20979
20980 /* Update connectivity flags for each port */
20981 _ssSetInputPortConnected(childS, 0, 1);
20982 _ssSetInputPortConnected(childS, 1, 1);
20983 _ssSetOutputPortConnected(childS, 0, 1);
20984 _ssSetOutputPortBeingMerged(childS, 0, 0);
20985
20986 /* Update the BufferDstPort flags for each input port */
20987 _ssSetInputPortBufferDstPort(childS, 0, -1);
20988 _ssSetInputPortBufferDstPort(childS, 1, -1);
20989 }
20990
20991 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S147>/Generated S-Function (Gain_sf) */
20992 {
20993 SimStruct *childS = ssGetSFunction(rts, 79);
20994
20995 /* timing info */
20996 time_T *sfcnPeriod;
20997 time_T *sfcnOffset;
20998 int_T *sfcnTsMap;
20999 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
21000 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
21001 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
21002 ss_VALIDATE_MEMORY(rts,sfcnOffset);
21003 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
21004 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
21005 (void) memset((void*)sfcnPeriod, 0,
21006 sizeof(time_T)*1);
21007 (void) memset((void*)sfcnOffset, 0,
21008 sizeof(time_T)*1);
21009 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
21010 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
21011 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
21012
21013 /* Set up the mdlInfo pointer */
21014# ifdef USE_RTMODEL
21015
21016 {
21017 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
21018 struct _ssBlkInfo2));
21019 ss_VALIDATE_MEMORY(rts,blkInfo2);
21020 ssSetBlkInfo2Ptr(childS, blkInfo2);
21021 }
21022
21023 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
21024
21025# else
21026
21027 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
21028
21029# endif /* USE_RTMODEL */
21030
21031 /* Allocate memory of model methods 2 */
21032 {
21033 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
21034 malloc(sizeof(struct _ssSFcnModelMethods2));
21035 ss_VALIDATE_MEMORY(rts,methods2);
21036 ssSetModelMethods2(childS, methods2);
21037 }
21038
21039 /* Allocate memory of model methods 3 */
21040 {
21041 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
21042 malloc(sizeof(struct _ssSFcnModelMethods3));
21043 ss_VALIDATE_MEMORY(rts,methods3);
21044 ssSetModelMethods3(childS, methods3);
21045 }
21046
21047 /* Allocate memory for states auxilliary information */
21048 {
21049 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
21050 (sizeof(struct _ssStatesInfo2));
21051 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
21052 malloc(sizeof(ssPeriodicStatesInfo));
21053 ss_VALIDATE_MEMORY(rts,statesInfo2);
21054 ssSetStatesInfo2(childS, statesInfo2);
21055 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
21056 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
21057 }
21058
21059 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
21060 RegNumInputPorts);
21061 ssSetRegNumInputPortsFcnArg(childS,childS);
21062
21063 /* inputs */
21064 {
21065 struct _ssPortInputs *inputPortInfo =
21066 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
21067 ss_VALIDATE_MEMORY(rts,inputPortInfo);
21068 _ssSetNumInputPorts(childS, 2);
21069 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
21070
21071 /* port 0 */
21072 {
21073 real32_T const **sfcnUPtrs = (real32_T const **)
21074 malloc(1 * sizeof(real32_T *));
21075 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21076 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
21077 ssGetLocalBlockIO(rts))->GeneratedSFunction_ma;
21078 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
21079 _ssSetInputPortNumDimensions(childS, 0, 1);
21080 ssSetInputPortWidth(childS, 0, 1);
21081 }
21082
21083 /* port 1 */
21084 {
21085 real32_T const **sfcnUPtrs = (real32_T const **)
21086 malloc(1 * sizeof(real32_T *));
21087 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21088 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
21089 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
21090 _ssSetInputPortNumDimensions(childS, 1, 1);
21091 ssSetInputPortWidth(childS, 1, 1);
21092 }
21093 }
21094
21095 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
21096 RegNumOutputPorts);
21097 ssSetRegNumOutputPortsFcnArg(childS,childS);
21098
21099 /* outputs */
21100 {
21101 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
21102 calloc(1, sizeof(struct _ssPortOutputs));
21103 ss_VALIDATE_MEMORY(rts,outputPortInfo);
21104 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
21105 _ssSetNumOutputPorts(childS, 1);
21106
21107 /* port 0 */
21108 {
21109 _ssSetOutputPortNumDimensions(childS, 0, 1);
21110 ssSetOutputPortWidth(childS, 0, 1);
21111 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
21112 ssGetLocalBlockIO(rts))->GeneratedSFunction_ck));
21113 }
21114 }
21115
21116 /* path info */
21117 _ssSetModelName(childS, "Gain_sf");
21118 _ssSetPath(childS,
21119 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/gain1/Generated S-Function");
21120 if (ssGetRTModel(rts) == (NULL)) {
21121 _ssSetParentSS(childS, rts);
21122 _ssSetRootSS(childS, ssGetRootSS(rts));
21123 } else {
21124 ssSetRTModel(childS,ssGetRTModel(rts));
21125 _ssSetParentSS(childS, (NULL));
21126 _ssSetRootSS(childS, childS);
21127 }
21128
21129 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
21130 (childS)->regDataType.arg1 = ((void *)(childS));
21131 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
21132 FcnSetErrorStatus);
21133 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
21134 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
21135 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
21136 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
21137
21138 /* registration */
21139#if defined(MATLAB_MEX_FILE)
21140
21141 {
21142 int_T i;
21143 mxArray *plhs[1];
21144 mxArray *prhs[4];
21145 double *pr;
21146 volatile int_T *intS = (int_T *)&childS;
21147 int_T addrlen = sizeof(SimStruct *);
21148 int_T m = addrlen/sizeof(int_T) + 1;
21149 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
21150 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
21151 pr = mxGetPr(prhs[1]);
21152 for (i = 0; i < m - 1; i++) {
21153 pr[i] = (double)intS[i];
21154 }
21155
21156 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
21157 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
21158 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
21159
21160 /* Reset port dimensions info functions because the S-function
21161 * and accelerator mex-files explicitly set their dimensions,
21162 * i.e., they are not dynamically sized. For this case, the
21163 * mex-file is responsible for the dimensions info memory
21164 * and Simulink should not free it. This is achieved by
21165 * setting the following two methods to NULL.
21166 */
21167 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
21168 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
21169
21170 /*
21171 * Setup function pointers and call mdlInitializeSizes via
21172 * simulink.c
21173 */
21174 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
21175 mxDestroyArray(plhs[0]);
21176 mxDestroyArray(prhs[0]);
21177 mxDestroyArray(prhs[1]);
21178 mxDestroyArray(prhs[2]);
21179 mxDestroyArray(prhs[3]);
21180 }
21181
21182#else
21183
21184 {
21185 Gain_sf(childS);
21186 sfcnInitializeSizes(childS);
21187 }
21188
21189#endif
21190
21191 sfcnInitializeSampleTimes(childS);
21192
21193 /* adjust sample time */
21194 ssSetSampleTime(childS, 0, 0.0);
21195 ssSetOffsetTime(childS, 0, 0.0);
21196 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
21197
21198 /* set compiled values of dynamic vector attributes */
21199 ssSetNumNonsampledZCs(childS, 0);
21200
21201 /* Update connectivity flags for each port */
21202 _ssSetInputPortConnected(childS, 0, 1);
21203 _ssSetInputPortConnected(childS, 1, 1);
21204 _ssSetOutputPortConnected(childS, 0, 1);
21205 _ssSetOutputPortBeingMerged(childS, 0, 0);
21206
21207 /* Update the BufferDstPort flags for each input port */
21208 _ssSetInputPortBufferDstPort(childS, 0, -1);
21209 _ssSetInputPortBufferDstPort(childS, 1, -1);
21210 }
21211
21212 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S140>/Generated S-Function3 (IntegratorLimited_sf) */
21213 {
21214 SimStruct *childS = ssGetSFunction(rts, 80);
21215
21216 /* timing info */
21217 time_T *sfcnPeriod;
21218 time_T *sfcnOffset;
21219 int_T *sfcnTsMap;
21220 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
21221 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
21222 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
21223 ss_VALIDATE_MEMORY(rts,sfcnOffset);
21224 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
21225 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
21226 (void) memset((void*)sfcnPeriod, 0,
21227 sizeof(time_T)*1);
21228 (void) memset((void*)sfcnOffset, 0,
21229 sizeof(time_T)*1);
21230 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
21231 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
21232 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
21233
21234 /* Set up the mdlInfo pointer */
21235# ifdef USE_RTMODEL
21236
21237 {
21238 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
21239 struct _ssBlkInfo2));
21240 ss_VALIDATE_MEMORY(rts,blkInfo2);
21241 ssSetBlkInfo2Ptr(childS, blkInfo2);
21242 }
21243
21244 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
21245
21246# else
21247
21248 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
21249
21250# endif /* USE_RTMODEL */
21251
21252 /* Allocate memory of model methods 2 */
21253 {
21254 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
21255 malloc(sizeof(struct _ssSFcnModelMethods2));
21256 ss_VALIDATE_MEMORY(rts,methods2);
21257 ssSetModelMethods2(childS, methods2);
21258 }
21259
21260 /* Allocate memory of model methods 3 */
21261 {
21262 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
21263 malloc(sizeof(struct _ssSFcnModelMethods3));
21264 ss_VALIDATE_MEMORY(rts,methods3);
21265 ssSetModelMethods3(childS, methods3);
21266 }
21267
21268 /* Allocate memory for states auxilliary information */
21269 {
21270 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
21271 (sizeof(struct _ssStatesInfo2));
21272 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
21273 malloc(sizeof(ssPeriodicStatesInfo));
21274 ss_VALIDATE_MEMORY(rts,statesInfo2);
21275 ssSetStatesInfo2(childS, statesInfo2);
21276 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
21277 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
21278 }
21279
21280 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
21281 RegNumInputPorts);
21282 ssSetRegNumInputPortsFcnArg(childS,childS);
21283
21284 /* inputs */
21285 {
21286 struct _ssPortInputs *inputPortInfo =
21287 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
21288 ss_VALIDATE_MEMORY(rts,inputPortInfo);
21289 _ssSetNumInputPorts(childS, 7);
21290 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
21291
21292 /* port 0 */
21293 {
21294 real32_T const **sfcnUPtrs = (real32_T const **)
21295 malloc(1 * sizeof(real32_T *));
21296 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21297 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
21298 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
21299 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
21300 _ssSetInputPortNumDimensions(childS, 0, 1);
21301 ssSetInputPortWidth(childS, 0, 1);
21302 }
21303
21304 /* port 1 */
21305 {
21306 int8_T const **sfcnUPtrs = (int8_T const **)
21307 malloc(1 * sizeof(int8_T *));
21308 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21309 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
21310 ssGetLocalBlockIO(rts))->DataTypeConversion2_p;
21311 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
21312 _ssSetInputPortNumDimensions(childS, 1, 1);
21313 ssSetInputPortWidth(childS, 1, 1);
21314 }
21315
21316 /* port 2 */
21317 {
21318 real32_T const **sfcnUPtrs = (real32_T const **)
21319 malloc(1 * sizeof(real32_T *));
21320 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21321 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
21322 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
21323 _ssSetInputPortNumDimensions(childS, 2, 1);
21324 ssSetInputPortWidth(childS, 2, 1);
21325 }
21326
21327 /* port 3 */
21328 {
21329 real32_T const **sfcnUPtrs = (real32_T const **)
21330 malloc(1 * sizeof(real32_T *));
21331 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21332 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
21333 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
21334 _ssSetInputPortNumDimensions(childS, 3, 1);
21335 ssSetInputPortWidth(childS, 3, 1);
21336 }
21337
21338 /* port 4 */
21339 {
21340 real32_T const **sfcnUPtrs = (real32_T const **)
21341 malloc(1 * sizeof(real32_T *));
21342 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21343 sfcnUPtrs[0] = (real32_T const *)
21344 &AFCS_MODEL1_ConstP.Constant29_Value;
21345 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
21346 _ssSetInputPortNumDimensions(childS, 4, 1);
21347 ssSetInputPortWidth(childS, 4, 1);
21348 }
21349
21350 /* port 5 */
21351 {
21352 real32_T const **sfcnUPtrs = (real32_T const **)
21353 malloc(1 * sizeof(real32_T *));
21354 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21355 sfcnUPtrs[0] = (real32_T const *)
21356 &AFCS_MODEL1_ConstP.Constant30_Value;
21357 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
21358 _ssSetInputPortNumDimensions(childS, 5, 1);
21359 ssSetInputPortWidth(childS, 5, 1);
21360 }
21361
21362 /* port 6 */
21363 {
21364 real32_T const **sfcnUPtrs = (real32_T const **)
21365 malloc(1 * sizeof(real32_T *));
21366 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21367 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
21368 ssGetLocalBlockIO(rts))->GeneratedSFunction_ck;
21369 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
21370 _ssSetInputPortNumDimensions(childS, 6, 1);
21371 ssSetInputPortWidth(childS, 6, 1);
21372 }
21373 }
21374
21375 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
21376 RegNumOutputPorts);
21377 ssSetRegNumOutputPortsFcnArg(childS,childS);
21378
21379 /* outputs */
21380 {
21381 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
21382 calloc(1, sizeof(struct _ssPortOutputs));
21383 ss_VALIDATE_MEMORY(rts,outputPortInfo);
21384 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
21385 _ssSetNumOutputPorts(childS, 1);
21386
21387 /* port 0 */
21388 {
21389 _ssSetOutputPortNumDimensions(childS, 0, 1);
21390 ssSetOutputPortWidth(childS, 0, 1);
21391 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
21392 ssGetLocalBlockIO(rts))->Saturation2_p));
21393 }
21394 }
21395
21396 /* path info */
21397 _ssSetModelName(childS, "IntegratorLimited_sf");
21398 _ssSetPath(childS,
21399 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Integrator Limited/Generated S-Function3");
21400 if (ssGetRTModel(rts) == (NULL)) {
21401 _ssSetParentSS(childS, rts);
21402 _ssSetRootSS(childS, ssGetRootSS(rts));
21403 } else {
21404 ssSetRTModel(childS,ssGetRTModel(rts));
21405 _ssSetParentSS(childS, (NULL));
21406 _ssSetRootSS(childS, childS);
21407 }
21408
21409 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
21410
21411 /* work vectors */
21412 {
21413 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
21414 (4 * sizeof(struct _ssDWorkRecord));
21415 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
21416 calloc(4, sizeof(struct _ssDWorkAuxRecord));
21417 ss_VALIDATE_MEMORY(rts,dWorkRecord);
21418 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
21419 ssSetSFcnDWork(childS, dWorkRecord);
21420 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
21421 _ssSetNumDWork(childS, 4);
21422
21423 /* DWORK0 */
21424 ssSetDWorkWidth(childS, 0, 1);
21425 ssSetDWorkDataType(childS, 0,SS_SINGLE);
21426 ssSetDWorkComplexSignal(childS, 0, 0);
21427 ssSetDWorkUsedAsDState(childS, 0, 1);
21428 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 208))[0]);
21429
21430 /* DWORK1 */
21431 ssSetDWorkWidth(childS, 1, 1);
21432 ssSetDWorkDataType(childS, 1,SS_SINGLE);
21433 ssSetDWorkComplexSignal(childS, 1, 0);
21434 ssSetDWorkUsedAsDState(childS, 1, 1);
21435 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 209))[0]);
21436
21437 /* DWORK2 */
21438 ssSetDWorkWidth(childS, 2, 1);
21439 ssSetDWorkDataType(childS, 2,SS_INT8);
21440 ssSetDWorkComplexSignal(childS, 2, 0);
21441 ssSetDWorkUsedAsDState(childS, 2, 1);
21442 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 435))[0]);
21443
21444 /* DWORK3 */
21445 ssSetDWorkWidth(childS, 3, 1);
21446 ssSetDWorkDataType(childS, 3,SS_INT8);
21447 ssSetDWorkComplexSignal(childS, 3, 0);
21448 ssSetDWorkUsedAsDState(childS, 3, 1);
21449 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 436))[0]);
21450 }
21451
21452 (childS)->regDataType.arg1 = ((void *)(childS));
21453 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
21454 FcnSetErrorStatus);
21455 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
21456 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
21457 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
21458 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
21459
21460 /* registration */
21461#if defined(MATLAB_MEX_FILE)
21462
21463 {
21464 int_T i;
21465 mxArray *plhs[1];
21466 mxArray *prhs[4];
21467 double *pr;
21468 volatile int_T *intS = (int_T *)&childS;
21469 int_T addrlen = sizeof(SimStruct *);
21470 int_T m = addrlen/sizeof(int_T) + 1;
21471 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
21472 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
21473 pr = mxGetPr(prhs[1]);
21474 for (i = 0; i < m - 1; i++) {
21475 pr[i] = (double)intS[i];
21476 }
21477
21478 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
21479 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
21480 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
21481
21482 /* Reset port dimensions info functions because the S-function
21483 * and accelerator mex-files explicitly set their dimensions,
21484 * i.e., they are not dynamically sized. For this case, the
21485 * mex-file is responsible for the dimensions info memory
21486 * and Simulink should not free it. This is achieved by
21487 * setting the following two methods to NULL.
21488 */
21489 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
21490 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
21491
21492 /*
21493 * Setup function pointers and call mdlInitializeSizes via
21494 * simulink.c
21495 */
21496 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
21497 mxDestroyArray(plhs[0]);
21498 mxDestroyArray(prhs[0]);
21499 mxDestroyArray(prhs[1]);
21500 mxDestroyArray(prhs[2]);
21501 mxDestroyArray(prhs[3]);
21502 }
21503
21504#else
21505
21506 {
21507 IntegratorLimited_sf(childS);
21508 sfcnInitializeSizes(childS);
21509 }
21510
21511#endif
21512
21513 sfcnInitializeSampleTimes(childS);
21514
21515 /* adjust sample time */
21516 ssSetSampleTime(childS, 0, 0.0);
21517 ssSetOffsetTime(childS, 0, 0.0);
21518 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
21519
21520 /* set compiled values of dynamic vector attributes */
21521 ssSetNumNonsampledZCs(childS, 0);
21522
21523 /* Update connectivity flags for each port */
21524 _ssSetInputPortConnected(childS, 0, 1);
21525 _ssSetInputPortConnected(childS, 1, 1);
21526 _ssSetInputPortConnected(childS, 2, 1);
21527 _ssSetInputPortConnected(childS, 3, 1);
21528 _ssSetInputPortConnected(childS, 4, 1);
21529 _ssSetInputPortConnected(childS, 5, 1);
21530 _ssSetInputPortConnected(childS, 6, 1);
21531 _ssSetOutputPortConnected(childS, 0, 1);
21532 _ssSetOutputPortBeingMerged(childS, 0, 0);
21533
21534 /* Update the BufferDstPort flags for each input port */
21535 _ssSetInputPortBufferDstPort(childS, 0, -1);
21536 _ssSetInputPortBufferDstPort(childS, 1, -1);
21537 _ssSetInputPortBufferDstPort(childS, 2, -1);
21538 _ssSetInputPortBufferDstPort(childS, 3, -1);
21539 _ssSetInputPortBufferDstPort(childS, 4, -1);
21540 _ssSetInputPortBufferDstPort(childS, 5, -1);
21541 _ssSetInputPortBufferDstPort(childS, 6, -1);
21542 }
21543
21544 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S141>/Generated S-Function2 (LeadLagFilter_sf) */
21545 {
21546 SimStruct *childS = ssGetSFunction(rts, 81);
21547
21548 /* timing info */
21549 time_T *sfcnPeriod;
21550 time_T *sfcnOffset;
21551 int_T *sfcnTsMap;
21552 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
21553 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
21554 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
21555 ss_VALIDATE_MEMORY(rts,sfcnOffset);
21556 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
21557 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
21558 (void) memset((void*)sfcnPeriod, 0,
21559 sizeof(time_T)*1);
21560 (void) memset((void*)sfcnOffset, 0,
21561 sizeof(time_T)*1);
21562 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
21563 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
21564 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
21565
21566 /* Set up the mdlInfo pointer */
21567# ifdef USE_RTMODEL
21568
21569 {
21570 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
21571 struct _ssBlkInfo2));
21572 ss_VALIDATE_MEMORY(rts,blkInfo2);
21573 ssSetBlkInfo2Ptr(childS, blkInfo2);
21574 }
21575
21576 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
21577
21578# else
21579
21580 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
21581
21582# endif /* USE_RTMODEL */
21583
21584 /* Allocate memory of model methods 2 */
21585 {
21586 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
21587 malloc(sizeof(struct _ssSFcnModelMethods2));
21588 ss_VALIDATE_MEMORY(rts,methods2);
21589 ssSetModelMethods2(childS, methods2);
21590 }
21591
21592 /* Allocate memory of model methods 3 */
21593 {
21594 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
21595 malloc(sizeof(struct _ssSFcnModelMethods3));
21596 ss_VALIDATE_MEMORY(rts,methods3);
21597 ssSetModelMethods3(childS, methods3);
21598 }
21599
21600 /* Allocate memory for states auxilliary information */
21601 {
21602 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
21603 (sizeof(struct _ssStatesInfo2));
21604 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
21605 malloc(sizeof(ssPeriodicStatesInfo));
21606 ss_VALIDATE_MEMORY(rts,statesInfo2);
21607 ssSetStatesInfo2(childS, statesInfo2);
21608 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
21609 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
21610 }
21611
21612 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
21613 RegNumInputPorts);
21614 ssSetRegNumInputPortsFcnArg(childS,childS);
21615
21616 /* inputs */
21617 {
21618 struct _ssPortInputs *inputPortInfo =
21619 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
21620 ss_VALIDATE_MEMORY(rts,inputPortInfo);
21621 _ssSetNumInputPorts(childS, 7);
21622 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
21623
21624 /* port 0 */
21625 {
21626 real32_T const **sfcnUPtrs = (real32_T const **)
21627 malloc(1 * sizeof(real32_T *));
21628 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21629 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
21630 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
21631 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
21632 _ssSetInputPortNumDimensions(childS, 0, 1);
21633 ssSetInputPortWidth(childS, 0, 1);
21634 }
21635
21636 /* port 1 */
21637 {
21638 int8_T const **sfcnUPtrs = (int8_T const **)
21639 malloc(1 * sizeof(int8_T *));
21640 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21641 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
21642 ssGetLocalBlockIO(rts))->DataTypeConversion2_p;
21643 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
21644 _ssSetInputPortNumDimensions(childS, 1, 1);
21645 ssSetInputPortWidth(childS, 1, 1);
21646 }
21647
21648 /* port 2 */
21649 {
21650 real32_T const **sfcnUPtrs = (real32_T const **)
21651 malloc(1 * sizeof(real32_T *));
21652 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21653 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
21654 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
21655 _ssSetInputPortNumDimensions(childS, 2, 1);
21656 ssSetInputPortWidth(childS, 2, 1);
21657 }
21658
21659 /* port 3 */
21660 {
21661 real32_T const **sfcnUPtrs = (real32_T const **)
21662 malloc(1 * sizeof(real32_T *));
21663 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21664 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
21665 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
21666 _ssSetInputPortNumDimensions(childS, 3, 1);
21667 ssSetInputPortWidth(childS, 3, 1);
21668 }
21669
21670 /* port 4 */
21671 {
21672 real32_T const **sfcnUPtrs = (real32_T const **)
21673 malloc(1 * sizeof(real32_T *));
21674 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21675 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
21676 ssGetLocalBlockIO(rts))->Switch_bg;
21677 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
21678 _ssSetInputPortNumDimensions(childS, 4, 1);
21679 ssSetInputPortWidth(childS, 4, 1);
21680 }
21681
21682 /* port 5 */
21683 {
21684 real32_T const **sfcnUPtrs = (real32_T const **)
21685 malloc(1 * sizeof(real32_T *));
21686 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21687 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
21688 ssGetLocalBlockIO(rts))->Switch_bg;
21689 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
21690 _ssSetInputPortNumDimensions(childS, 5, 1);
21691 ssSetInputPortWidth(childS, 5, 1);
21692 }
21693
21694 /* port 6 */
21695 {
21696 real32_T const **sfcnUPtrs = (real32_T const **)
21697 malloc(1 * sizeof(real32_T *));
21698 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21699 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
21700 ssGetLocalBlockIO(rts))->Sum_mz;
21701 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
21702 _ssSetInputPortNumDimensions(childS, 6, 1);
21703 ssSetInputPortWidth(childS, 6, 1);
21704 }
21705 }
21706
21707 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
21708 RegNumOutputPorts);
21709 ssSetRegNumOutputPortsFcnArg(childS,childS);
21710
21711 /* outputs */
21712 {
21713 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
21714 calloc(1, sizeof(struct _ssPortOutputs));
21715 ss_VALIDATE_MEMORY(rts,outputPortInfo);
21716 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
21717 _ssSetNumOutputPorts(childS, 1);
21718
21719 /* port 0 */
21720 {
21721 _ssSetOutputPortNumDimensions(childS, 0, 1);
21722 ssSetOutputPortWidth(childS, 0, 1);
21723 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
21724 ssGetLocalBlockIO(rts))->GeneratedSFunction2_n));
21725 }
21726 }
21727
21728 /* path info */
21729 _ssSetModelName(childS, "LeadLagFilter_sf");
21730 _ssSetPath(childS,
21731 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/Lead lag/Generated S-Function2");
21732 if (ssGetRTModel(rts) == (NULL)) {
21733 _ssSetParentSS(childS, rts);
21734 _ssSetRootSS(childS, ssGetRootSS(rts));
21735 } else {
21736 ssSetRTModel(childS,ssGetRTModel(rts));
21737 _ssSetParentSS(childS, (NULL));
21738 _ssSetRootSS(childS, childS);
21739 }
21740
21741 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
21742
21743 /* work vectors */
21744 {
21745 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
21746 (4 * sizeof(struct _ssDWorkRecord));
21747 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
21748 calloc(4, sizeof(struct _ssDWorkAuxRecord));
21749 ss_VALIDATE_MEMORY(rts,dWorkRecord);
21750 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
21751 ssSetSFcnDWork(childS, dWorkRecord);
21752 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
21753 _ssSetNumDWork(childS, 4);
21754
21755 /* DWORK0 */
21756 ssSetDWorkWidth(childS, 0, 1);
21757 ssSetDWorkDataType(childS, 0,SS_SINGLE);
21758 ssSetDWorkComplexSignal(childS, 0, 0);
21759 ssSetDWorkUsedAsDState(childS, 0, 1);
21760 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 210))[0]);
21761
21762 /* DWORK1 */
21763 ssSetDWorkWidth(childS, 1, 1);
21764 ssSetDWorkDataType(childS, 1,SS_SINGLE);
21765 ssSetDWorkComplexSignal(childS, 1, 0);
21766 ssSetDWorkUsedAsDState(childS, 1, 1);
21767 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 211))[0]);
21768
21769 /* DWORK2 */
21770 ssSetDWorkWidth(childS, 2, 1);
21771 ssSetDWorkDataType(childS, 2,SS_INT8);
21772 ssSetDWorkComplexSignal(childS, 2, 0);
21773 ssSetDWorkUsedAsDState(childS, 2, 1);
21774 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 437))[0]);
21775
21776 /* DWORK3 */
21777 ssSetDWorkWidth(childS, 3, 1);
21778 ssSetDWorkDataType(childS, 3,SS_INT8);
21779 ssSetDWorkComplexSignal(childS, 3, 0);
21780 ssSetDWorkUsedAsDState(childS, 3, 1);
21781 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 438))[0]);
21782 }
21783
21784 (childS)->regDataType.arg1 = ((void *)(childS));
21785 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
21786 FcnSetErrorStatus);
21787 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
21788 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
21789 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
21790 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
21791
21792 /* registration */
21793#if defined(MATLAB_MEX_FILE)
21794
21795 {
21796 int_T i;
21797 mxArray *plhs[1];
21798 mxArray *prhs[4];
21799 double *pr;
21800 volatile int_T *intS = (int_T *)&childS;
21801 int_T addrlen = sizeof(SimStruct *);
21802 int_T m = addrlen/sizeof(int_T) + 1;
21803 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
21804 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
21805 pr = mxGetPr(prhs[1]);
21806 for (i = 0; i < m - 1; i++) {
21807 pr[i] = (double)intS[i];
21808 }
21809
21810 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
21811 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
21812 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
21813
21814 /* Reset port dimensions info functions because the S-function
21815 * and accelerator mex-files explicitly set their dimensions,
21816 * i.e., they are not dynamically sized. For this case, the
21817 * mex-file is responsible for the dimensions info memory
21818 * and Simulink should not free it. This is achieved by
21819 * setting the following two methods to NULL.
21820 */
21821 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
21822 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
21823
21824 /*
21825 * Setup function pointers and call mdlInitializeSizes via
21826 * simulink.c
21827 */
21828 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
21829 mxDestroyArray(plhs[0]);
21830 mxDestroyArray(prhs[0]);
21831 mxDestroyArray(prhs[1]);
21832 mxDestroyArray(prhs[2]);
21833 mxDestroyArray(prhs[3]);
21834 }
21835
21836#else
21837
21838 {
21839 LeadLagFilter_sf(childS);
21840 sfcnInitializeSizes(childS);
21841 }
21842
21843#endif
21844
21845 sfcnInitializeSampleTimes(childS);
21846
21847 /* adjust sample time */
21848 ssSetSampleTime(childS, 0, 0.0);
21849 ssSetOffsetTime(childS, 0, 0.0);
21850 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
21851
21852 /* set compiled values of dynamic vector attributes */
21853 ssSetNumNonsampledZCs(childS, 0);
21854
21855 /* Update connectivity flags for each port */
21856 _ssSetInputPortConnected(childS, 0, 1);
21857 _ssSetInputPortConnected(childS, 1, 1);
21858 _ssSetInputPortConnected(childS, 2, 1);
21859 _ssSetInputPortConnected(childS, 3, 1);
21860 _ssSetInputPortConnected(childS, 4, 1);
21861 _ssSetInputPortConnected(childS, 5, 1);
21862 _ssSetInputPortConnected(childS, 6, 1);
21863 _ssSetOutputPortConnected(childS, 0, 1);
21864 _ssSetOutputPortBeingMerged(childS, 0, 0);
21865
21866 /* Update the BufferDstPort flags for each input port */
21867 _ssSetInputPortBufferDstPort(childS, 0, -1);
21868 _ssSetInputPortBufferDstPort(childS, 1, -1);
21869 _ssSetInputPortBufferDstPort(childS, 2, -1);
21870 _ssSetInputPortBufferDstPort(childS, 3, -1);
21871 _ssSetInputPortBufferDstPort(childS, 4, -1);
21872 _ssSetInputPortBufferDstPort(childS, 5, -1);
21873 _ssSetInputPortBufferDstPort(childS, 6, -1);
21874 }
21875
21876 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S139>/Generated S-Function4 (LagFilter_sf) */
21877 {
21878 SimStruct *childS = ssGetSFunction(rts, 82);
21879
21880 /* timing info */
21881 time_T *sfcnPeriod;
21882 time_T *sfcnOffset;
21883 int_T *sfcnTsMap;
21884 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
21885 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
21886 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
21887 ss_VALIDATE_MEMORY(rts,sfcnOffset);
21888 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
21889 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
21890 (void) memset((void*)sfcnPeriod, 0,
21891 sizeof(time_T)*1);
21892 (void) memset((void*)sfcnOffset, 0,
21893 sizeof(time_T)*1);
21894 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
21895 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
21896 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
21897
21898 /* Set up the mdlInfo pointer */
21899# ifdef USE_RTMODEL
21900
21901 {
21902 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
21903 struct _ssBlkInfo2));
21904 ss_VALIDATE_MEMORY(rts,blkInfo2);
21905 ssSetBlkInfo2Ptr(childS, blkInfo2);
21906 }
21907
21908 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
21909
21910# else
21911
21912 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
21913
21914# endif /* USE_RTMODEL */
21915
21916 /* Allocate memory of model methods 2 */
21917 {
21918 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
21919 malloc(sizeof(struct _ssSFcnModelMethods2));
21920 ss_VALIDATE_MEMORY(rts,methods2);
21921 ssSetModelMethods2(childS, methods2);
21922 }
21923
21924 /* Allocate memory of model methods 3 */
21925 {
21926 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
21927 malloc(sizeof(struct _ssSFcnModelMethods3));
21928 ss_VALIDATE_MEMORY(rts,methods3);
21929 ssSetModelMethods3(childS, methods3);
21930 }
21931
21932 /* Allocate memory for states auxilliary information */
21933 {
21934 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
21935 (sizeof(struct _ssStatesInfo2));
21936 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
21937 malloc(sizeof(ssPeriodicStatesInfo));
21938 ss_VALIDATE_MEMORY(rts,statesInfo2);
21939 ssSetStatesInfo2(childS, statesInfo2);
21940 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
21941 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
21942 }
21943
21944 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
21945 RegNumInputPorts);
21946 ssSetRegNumInputPortsFcnArg(childS,childS);
21947
21948 /* inputs */
21949 {
21950 struct _ssPortInputs *inputPortInfo =
21951 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
21952 ss_VALIDATE_MEMORY(rts,inputPortInfo);
21953 _ssSetNumInputPorts(childS, 6);
21954 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
21955
21956 /* port 0 */
21957 {
21958 real32_T const **sfcnUPtrs = (real32_T const **)
21959 malloc(1 * sizeof(real32_T *));
21960 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21961 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
21962 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
21963 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
21964 _ssSetInputPortNumDimensions(childS, 0, 1);
21965 ssSetInputPortWidth(childS, 0, 1);
21966 }
21967
21968 /* port 1 */
21969 {
21970 int8_T const **sfcnUPtrs = (int8_T const **)
21971 malloc(1 * sizeof(int8_T *));
21972 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21973 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
21974 ssGetLocalBlockIO(rts))->DataTypeConversion2_p;
21975 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
21976 _ssSetInputPortNumDimensions(childS, 1, 1);
21977 ssSetInputPortWidth(childS, 1, 1);
21978 }
21979
21980 /* port 2 */
21981 {
21982 real32_T const **sfcnUPtrs = (real32_T const **)
21983 malloc(1 * sizeof(real32_T *));
21984 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21985 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
21986 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
21987 _ssSetInputPortNumDimensions(childS, 2, 1);
21988 ssSetInputPortWidth(childS, 2, 1);
21989 }
21990
21991 /* port 3 */
21992 {
21993 real32_T const **sfcnUPtrs = (real32_T const **)
21994 malloc(1 * sizeof(real32_T *));
21995 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
21996 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
21997 ssGetLocalBlockIO(rts))->Switch_bg;
21998 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
21999 _ssSetInputPortNumDimensions(childS, 3, 1);
22000 ssSetInputPortWidth(childS, 3, 1);
22001 }
22002
22003 /* port 4 */
22004 {
22005 real32_T const **sfcnUPtrs = (real32_T const **)
22006 malloc(1 * sizeof(real32_T *));
22007 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22008 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
22009 ssGetLocalBlockIO(rts))->Switch_bg;
22010 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
22011 _ssSetInputPortNumDimensions(childS, 4, 1);
22012 ssSetInputPortWidth(childS, 4, 1);
22013 }
22014
22015 /* port 5 */
22016 {
22017 real32_T const **sfcnUPtrs = (real32_T const **)
22018 malloc(1 * sizeof(real32_T *));
22019 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22020 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
22021 ssGetLocalBlockIO(rts))->GeneratedSFunction2_n;
22022 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
22023 _ssSetInputPortNumDimensions(childS, 5, 1);
22024 ssSetInputPortWidth(childS, 5, 1);
22025 }
22026 }
22027
22028 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
22029 RegNumOutputPorts);
22030 ssSetRegNumOutputPortsFcnArg(childS,childS);
22031
22032 /* outputs */
22033 {
22034 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
22035 calloc(1, sizeof(struct _ssPortOutputs));
22036 ss_VALIDATE_MEMORY(rts,outputPortInfo);
22037 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
22038 _ssSetNumOutputPorts(childS, 1);
22039
22040 /* port 0 */
22041 {
22042 _ssSetOutputPortNumDimensions(childS, 0, 1);
22043 ssSetOutputPortWidth(childS, 0, 1);
22044 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
22045 ssGetLocalBlockIO(rts))->GeneratedSFunction4_cg));
22046 }
22047 }
22048
22049 /* path info */
22050 _ssSetModelName(childS, "LagFilter_sf");
22051 _ssSetPath(childS,
22052 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/PsdLControl/ lag filter/Generated S-Function4");
22053 if (ssGetRTModel(rts) == (NULL)) {
22054 _ssSetParentSS(childS, rts);
22055 _ssSetRootSS(childS, ssGetRootSS(rts));
22056 } else {
22057 ssSetRTModel(childS,ssGetRTModel(rts));
22058 _ssSetParentSS(childS, (NULL));
22059 _ssSetRootSS(childS, childS);
22060 }
22061
22062 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
22063
22064 /* work vectors */
22065 {
22066 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
22067 (4 * sizeof(struct _ssDWorkRecord));
22068 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
22069 calloc(4, sizeof(struct _ssDWorkAuxRecord));
22070 ss_VALIDATE_MEMORY(rts,dWorkRecord);
22071 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
22072 ssSetSFcnDWork(childS, dWorkRecord);
22073 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
22074 _ssSetNumDWork(childS, 4);
22075
22076 /* DWORK0 */
22077 ssSetDWorkWidth(childS, 0, 1);
22078 ssSetDWorkDataType(childS, 0,SS_SINGLE);
22079 ssSetDWorkComplexSignal(childS, 0, 0);
22080 ssSetDWorkUsedAsDState(childS, 0, 1);
22081 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 212))[0]);
22082
22083 /* DWORK1 */
22084 ssSetDWorkWidth(childS, 1, 1);
22085 ssSetDWorkDataType(childS, 1,SS_SINGLE);
22086 ssSetDWorkComplexSignal(childS, 1, 0);
22087 ssSetDWorkUsedAsDState(childS, 1, 1);
22088 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 213))[0]);
22089
22090 /* DWORK2 */
22091 ssSetDWorkWidth(childS, 2, 1);
22092 ssSetDWorkDataType(childS, 2,SS_INT8);
22093 ssSetDWorkComplexSignal(childS, 2, 0);
22094 ssSetDWorkUsedAsDState(childS, 2, 1);
22095 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 439))[0]);
22096
22097 /* DWORK3 */
22098 ssSetDWorkWidth(childS, 3, 1);
22099 ssSetDWorkDataType(childS, 3,SS_INT8);
22100 ssSetDWorkComplexSignal(childS, 3, 0);
22101 ssSetDWorkUsedAsDState(childS, 3, 1);
22102 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 440))[0]);
22103 }
22104
22105 (childS)->regDataType.arg1 = ((void *)(childS));
22106 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
22107 FcnSetErrorStatus);
22108 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
22109 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
22110 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
22111 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
22112
22113 /* registration */
22114#if defined(MATLAB_MEX_FILE)
22115
22116 {
22117 int_T i;
22118 mxArray *plhs[1];
22119 mxArray *prhs[4];
22120 double *pr;
22121 volatile int_T *intS = (int_T *)&childS;
22122 int_T addrlen = sizeof(SimStruct *);
22123 int_T m = addrlen/sizeof(int_T) + 1;
22124 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
22125 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
22126 pr = mxGetPr(prhs[1]);
22127 for (i = 0; i < m - 1; i++) {
22128 pr[i] = (double)intS[i];
22129 }
22130
22131 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
22132 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
22133 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
22134
22135 /* Reset port dimensions info functions because the S-function
22136 * and accelerator mex-files explicitly set their dimensions,
22137 * i.e., they are not dynamically sized. For this case, the
22138 * mex-file is responsible for the dimensions info memory
22139 * and Simulink should not free it. This is achieved by
22140 * setting the following two methods to NULL.
22141 */
22142 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
22143 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
22144
22145 /*
22146 * Setup function pointers and call mdlInitializeSizes via
22147 * simulink.c
22148 */
22149 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
22150 mxDestroyArray(plhs[0]);
22151 mxDestroyArray(prhs[0]);
22152 mxDestroyArray(prhs[1]);
22153 mxDestroyArray(prhs[2]);
22154 mxDestroyArray(prhs[3]);
22155 }
22156
22157#else
22158
22159 {
22160 LagFilter_sf(childS);
22161 sfcnInitializeSizes(childS);
22162 }
22163
22164#endif
22165
22166 sfcnInitializeSampleTimes(childS);
22167
22168 /* adjust sample time */
22169 ssSetSampleTime(childS, 0, 0.0);
22170 ssSetOffsetTime(childS, 0, 0.0);
22171 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
22172
22173 /* set compiled values of dynamic vector attributes */
22174 ssSetNumNonsampledZCs(childS, 0);
22175
22176 /* Update connectivity flags for each port */
22177 _ssSetInputPortConnected(childS, 0, 1);
22178 _ssSetInputPortConnected(childS, 1, 1);
22179 _ssSetInputPortConnected(childS, 2, 1);
22180 _ssSetInputPortConnected(childS, 3, 1);
22181 _ssSetInputPortConnected(childS, 4, 1);
22182 _ssSetInputPortConnected(childS, 5, 1);
22183 _ssSetOutputPortConnected(childS, 0, 1);
22184 _ssSetOutputPortBeingMerged(childS, 0, 0);
22185
22186 /* Update the BufferDstPort flags for each input port */
22187 _ssSetInputPortBufferDstPort(childS, 0, -1);
22188 _ssSetInputPortBufferDstPort(childS, 1, -1);
22189 _ssSetInputPortBufferDstPort(childS, 2, -1);
22190 _ssSetInputPortBufferDstPort(childS, 3, -1);
22191 _ssSetInputPortBufferDstPort(childS, 4, -1);
22192 _ssSetInputPortBufferDstPort(childS, 5, -1);
22193 }
22194
22195 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S164>/Generated S-Function1 (SaturationLimiter_sf) */
22196 {
22197 SimStruct *childS = ssGetSFunction(rts, 83);
22198
22199 /* timing info */
22200 time_T *sfcnPeriod;
22201 time_T *sfcnOffset;
22202 int_T *sfcnTsMap;
22203 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
22204 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
22205 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
22206 ss_VALIDATE_MEMORY(rts,sfcnOffset);
22207 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
22208 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
22209 (void) memset((void*)sfcnPeriod, 0,
22210 sizeof(time_T)*1);
22211 (void) memset((void*)sfcnOffset, 0,
22212 sizeof(time_T)*1);
22213 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
22214 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
22215 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
22216
22217 /* Set up the mdlInfo pointer */
22218# ifdef USE_RTMODEL
22219
22220 {
22221 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
22222 struct _ssBlkInfo2));
22223 ss_VALIDATE_MEMORY(rts,blkInfo2);
22224 ssSetBlkInfo2Ptr(childS, blkInfo2);
22225 }
22226
22227 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
22228
22229# else
22230
22231 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
22232
22233# endif /* USE_RTMODEL */
22234
22235 /* Allocate memory of model methods 2 */
22236 {
22237 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
22238 malloc(sizeof(struct _ssSFcnModelMethods2));
22239 ss_VALIDATE_MEMORY(rts,methods2);
22240 ssSetModelMethods2(childS, methods2);
22241 }
22242
22243 /* Allocate memory of model methods 3 */
22244 {
22245 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
22246 malloc(sizeof(struct _ssSFcnModelMethods3));
22247 ss_VALIDATE_MEMORY(rts,methods3);
22248 ssSetModelMethods3(childS, methods3);
22249 }
22250
22251 /* Allocate memory for states auxilliary information */
22252 {
22253 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
22254 (sizeof(struct _ssStatesInfo2));
22255 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
22256 malloc(sizeof(ssPeriodicStatesInfo));
22257 ss_VALIDATE_MEMORY(rts,statesInfo2);
22258 ssSetStatesInfo2(childS, statesInfo2);
22259 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
22260 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
22261 }
22262
22263 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
22264 RegNumInputPorts);
22265 ssSetRegNumInputPortsFcnArg(childS,childS);
22266
22267 /* inputs */
22268 {
22269 struct _ssPortInputs *inputPortInfo =
22270 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
22271 ss_VALIDATE_MEMORY(rts,inputPortInfo);
22272 _ssSetNumInputPorts(childS, 3);
22273 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
22274
22275 /* port 0 */
22276 {
22277 real32_T const **sfcnUPtrs = (real32_T const **)
22278 malloc(1 * sizeof(real32_T *));
22279 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22280 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
22281 ssGetLocalBlockIO(rts))->Sum2_hh;
22282 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
22283 _ssSetInputPortNumDimensions(childS, 0, 1);
22284 ssSetInputPortWidth(childS, 0, 1);
22285 }
22286
22287 /* port 1 */
22288 {
22289 real32_T const **sfcnUPtrs = (real32_T const **)
22290 malloc(1 * sizeof(real32_T *));
22291 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22292 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;
22293 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
22294 _ssSetInputPortNumDimensions(childS, 1, 1);
22295 ssSetInputPortWidth(childS, 1, 1);
22296 }
22297
22298 /* port 2 */
22299 {
22300 real32_T const **sfcnUPtrs = (real32_T const **)
22301 malloc(1 * sizeof(real32_T *));
22302 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22303 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;
22304 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
22305 _ssSetInputPortNumDimensions(childS, 2, 1);
22306 ssSetInputPortWidth(childS, 2, 1);
22307 }
22308 }
22309
22310 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
22311 RegNumOutputPorts);
22312 ssSetRegNumOutputPortsFcnArg(childS,childS);
22313
22314 /* outputs */
22315 {
22316 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
22317 calloc(1, sizeof(struct _ssPortOutputs));
22318 ss_VALIDATE_MEMORY(rts,outputPortInfo);
22319 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
22320 _ssSetNumOutputPorts(childS, 1);
22321
22322 /* port 0 */
22323 {
22324 _ssSetOutputPortNumDimensions(childS, 0, 1);
22325 ssSetOutputPortWidth(childS, 0, 1);
22326 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
22327 ssGetLocalBlockIO(rts))->GeneratedSFunction1_n1));
22328 }
22329 }
22330
22331 /* path info */
22332 _ssSetModelName(childS, "SaturationLimiter_sf");
22333 _ssSetPath(childS,
22334 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter3/Generated S-Function1");
22335 if (ssGetRTModel(rts) == (NULL)) {
22336 _ssSetParentSS(childS, rts);
22337 _ssSetRootSS(childS, ssGetRootSS(rts));
22338 } else {
22339 ssSetRTModel(childS,ssGetRTModel(rts));
22340 _ssSetParentSS(childS, (NULL));
22341 _ssSetRootSS(childS, childS);
22342 }
22343
22344 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
22345 (childS)->regDataType.arg1 = ((void *)(childS));
22346 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
22347 FcnSetErrorStatus);
22348 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
22349 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
22350 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
22351 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
22352
22353 /* registration */
22354#if defined(MATLAB_MEX_FILE)
22355
22356 {
22357 int_T i;
22358 mxArray *plhs[1];
22359 mxArray *prhs[4];
22360 double *pr;
22361 volatile int_T *intS = (int_T *)&childS;
22362 int_T addrlen = sizeof(SimStruct *);
22363 int_T m = addrlen/sizeof(int_T) + 1;
22364 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
22365 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
22366 pr = mxGetPr(prhs[1]);
22367 for (i = 0; i < m - 1; i++) {
22368 pr[i] = (double)intS[i];
22369 }
22370
22371 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
22372 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
22373 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
22374
22375 /* Reset port dimensions info functions because the S-function
22376 * and accelerator mex-files explicitly set their dimensions,
22377 * i.e., they are not dynamically sized. For this case, the
22378 * mex-file is responsible for the dimensions info memory
22379 * and Simulink should not free it. This is achieved by
22380 * setting the following two methods to NULL.
22381 */
22382 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
22383 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
22384
22385 /*
22386 * Setup function pointers and call mdlInitializeSizes via
22387 * simulink.c
22388 */
22389 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
22390 mxDestroyArray(plhs[0]);
22391 mxDestroyArray(prhs[0]);
22392 mxDestroyArray(prhs[1]);
22393 mxDestroyArray(prhs[2]);
22394 mxDestroyArray(prhs[3]);
22395 }
22396
22397#else
22398
22399 {
22400 SaturationLimiter_sf(childS);
22401 sfcnInitializeSizes(childS);
22402 }
22403
22404#endif
22405
22406 sfcnInitializeSampleTimes(childS);
22407
22408 /* adjust sample time */
22409 ssSetSampleTime(childS, 0, 0.0);
22410 ssSetOffsetTime(childS, 0, 0.0);
22411 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
22412
22413 /* set compiled values of dynamic vector attributes */
22414 ssSetNumNonsampledZCs(childS, 0);
22415
22416 /* Update connectivity flags for each port */
22417 _ssSetInputPortConnected(childS, 0, 1);
22418 _ssSetInputPortConnected(childS, 1, 1);
22419 _ssSetInputPortConnected(childS, 2, 1);
22420 _ssSetOutputPortConnected(childS, 0, 1);
22421 _ssSetOutputPortBeingMerged(childS, 0, 0);
22422
22423 /* Update the BufferDstPort flags for each input port */
22424 _ssSetInputPortBufferDstPort(childS, 0, -1);
22425 _ssSetInputPortBufferDstPort(childS, 1, -1);
22426 _ssSetInputPortBufferDstPort(childS, 2, -1);
22427 }
22428
22429 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S168>/Generated S-Function (Gain_sf) */
22430 {
22431 SimStruct *childS = ssGetSFunction(rts, 84);
22432
22433 /* timing info */
22434 time_T *sfcnPeriod;
22435 time_T *sfcnOffset;
22436 int_T *sfcnTsMap;
22437 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
22438 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
22439 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
22440 ss_VALIDATE_MEMORY(rts,sfcnOffset);
22441 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
22442 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
22443 (void) memset((void*)sfcnPeriod, 0,
22444 sizeof(time_T)*1);
22445 (void) memset((void*)sfcnOffset, 0,
22446 sizeof(time_T)*1);
22447 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
22448 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
22449 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
22450
22451 /* Set up the mdlInfo pointer */
22452# ifdef USE_RTMODEL
22453
22454 {
22455 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
22456 struct _ssBlkInfo2));
22457 ss_VALIDATE_MEMORY(rts,blkInfo2);
22458 ssSetBlkInfo2Ptr(childS, blkInfo2);
22459 }
22460
22461 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
22462
22463# else
22464
22465 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
22466
22467# endif /* USE_RTMODEL */
22468
22469 /* Allocate memory of model methods 2 */
22470 {
22471 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
22472 malloc(sizeof(struct _ssSFcnModelMethods2));
22473 ss_VALIDATE_MEMORY(rts,methods2);
22474 ssSetModelMethods2(childS, methods2);
22475 }
22476
22477 /* Allocate memory of model methods 3 */
22478 {
22479 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
22480 malloc(sizeof(struct _ssSFcnModelMethods3));
22481 ss_VALIDATE_MEMORY(rts,methods3);
22482 ssSetModelMethods3(childS, methods3);
22483 }
22484
22485 /* Allocate memory for states auxilliary information */
22486 {
22487 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
22488 (sizeof(struct _ssStatesInfo2));
22489 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
22490 malloc(sizeof(ssPeriodicStatesInfo));
22491 ss_VALIDATE_MEMORY(rts,statesInfo2);
22492 ssSetStatesInfo2(childS, statesInfo2);
22493 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
22494 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
22495 }
22496
22497 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
22498 RegNumInputPorts);
22499 ssSetRegNumInputPortsFcnArg(childS,childS);
22500
22501 /* inputs */
22502 {
22503 struct _ssPortInputs *inputPortInfo =
22504 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
22505 ss_VALIDATE_MEMORY(rts,inputPortInfo);
22506 _ssSetNumInputPorts(childS, 2);
22507 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
22508
22509 /* port 0 */
22510 {
22511 real32_T const **sfcnUPtrs = (real32_T const **)
22512 malloc(1 * sizeof(real32_T *));
22513 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22514 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
22515 ssGetLocalBlockIO(rts))->GeneratedSFunction1_n1;
22516 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
22517 _ssSetInputPortNumDimensions(childS, 0, 1);
22518 ssSetInputPortWidth(childS, 0, 1);
22519 }
22520
22521 /* port 1 */
22522 {
22523 real32_T const **sfcnUPtrs = (real32_T const **)
22524 malloc(1 * sizeof(real32_T *));
22525 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22526 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled123;
22527 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
22528 _ssSetInputPortNumDimensions(childS, 1, 1);
22529 ssSetInputPortWidth(childS, 1, 1);
22530 }
22531 }
22532
22533 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
22534 RegNumOutputPorts);
22535 ssSetRegNumOutputPortsFcnArg(childS,childS);
22536
22537 /* outputs */
22538 {
22539 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
22540 calloc(1, sizeof(struct _ssPortOutputs));
22541 ss_VALIDATE_MEMORY(rts,outputPortInfo);
22542 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
22543 _ssSetNumOutputPorts(childS, 1);
22544
22545 /* port 0 */
22546 {
22547 _ssSetOutputPortNumDimensions(childS, 0, 1);
22548 ssSetOutputPortWidth(childS, 0, 1);
22549 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
22550 ssGetLocalBlockIO(rts))->GeneratedSFunction_fb));
22551 }
22552 }
22553
22554 /* path info */
22555 _ssSetModelName(childS, "Gain_sf");
22556 _ssSetPath(childS,
22557 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/gain3/Generated S-Function");
22558 if (ssGetRTModel(rts) == (NULL)) {
22559 _ssSetParentSS(childS, rts);
22560 _ssSetRootSS(childS, ssGetRootSS(rts));
22561 } else {
22562 ssSetRTModel(childS,ssGetRTModel(rts));
22563 _ssSetParentSS(childS, (NULL));
22564 _ssSetRootSS(childS, childS);
22565 }
22566
22567 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
22568 (childS)->regDataType.arg1 = ((void *)(childS));
22569 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
22570 FcnSetErrorStatus);
22571 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
22572 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
22573 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
22574 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
22575
22576 /* registration */
22577#if defined(MATLAB_MEX_FILE)
22578
22579 {
22580 int_T i;
22581 mxArray *plhs[1];
22582 mxArray *prhs[4];
22583 double *pr;
22584 volatile int_T *intS = (int_T *)&childS;
22585 int_T addrlen = sizeof(SimStruct *);
22586 int_T m = addrlen/sizeof(int_T) + 1;
22587 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
22588 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
22589 pr = mxGetPr(prhs[1]);
22590 for (i = 0; i < m - 1; i++) {
22591 pr[i] = (double)intS[i];
22592 }
22593
22594 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
22595 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
22596 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
22597
22598 /* Reset port dimensions info functions because the S-function
22599 * and accelerator mex-files explicitly set their dimensions,
22600 * i.e., they are not dynamically sized. For this case, the
22601 * mex-file is responsible for the dimensions info memory
22602 * and Simulink should not free it. This is achieved by
22603 * setting the following two methods to NULL.
22604 */
22605 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
22606 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
22607
22608 /*
22609 * Setup function pointers and call mdlInitializeSizes via
22610 * simulink.c
22611 */
22612 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
22613 mxDestroyArray(plhs[0]);
22614 mxDestroyArray(prhs[0]);
22615 mxDestroyArray(prhs[1]);
22616 mxDestroyArray(prhs[2]);
22617 mxDestroyArray(prhs[3]);
22618 }
22619
22620#else
22621
22622 {
22623 Gain_sf(childS);
22624 sfcnInitializeSizes(childS);
22625 }
22626
22627#endif
22628
22629 sfcnInitializeSampleTimes(childS);
22630
22631 /* adjust sample time */
22632 ssSetSampleTime(childS, 0, 0.0);
22633 ssSetOffsetTime(childS, 0, 0.0);
22634 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
22635
22636 /* set compiled values of dynamic vector attributes */
22637 ssSetNumNonsampledZCs(childS, 0);
22638
22639 /* Update connectivity flags for each port */
22640 _ssSetInputPortConnected(childS, 0, 1);
22641 _ssSetInputPortConnected(childS, 1, 1);
22642 _ssSetOutputPortConnected(childS, 0, 1);
22643 _ssSetOutputPortBeingMerged(childS, 0, 0);
22644
22645 /* Update the BufferDstPort flags for each input port */
22646 _ssSetInputPortBufferDstPort(childS, 0, -1);
22647 _ssSetInputPortBufferDstPort(childS, 1, -1);
22648 }
22649
22650 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S169>/Generated S-Function (Gain_sf) */
22651 {
22652 SimStruct *childS = ssGetSFunction(rts, 85);
22653
22654 /* timing info */
22655 time_T *sfcnPeriod;
22656 time_T *sfcnOffset;
22657 int_T *sfcnTsMap;
22658 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
22659 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
22660 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
22661 ss_VALIDATE_MEMORY(rts,sfcnOffset);
22662 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
22663 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
22664 (void) memset((void*)sfcnPeriod, 0,
22665 sizeof(time_T)*1);
22666 (void) memset((void*)sfcnOffset, 0,
22667 sizeof(time_T)*1);
22668 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
22669 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
22670 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
22671
22672 /* Set up the mdlInfo pointer */
22673# ifdef USE_RTMODEL
22674
22675 {
22676 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
22677 struct _ssBlkInfo2));
22678 ss_VALIDATE_MEMORY(rts,blkInfo2);
22679 ssSetBlkInfo2Ptr(childS, blkInfo2);
22680 }
22681
22682 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
22683
22684# else
22685
22686 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
22687
22688# endif /* USE_RTMODEL */
22689
22690 /* Allocate memory of model methods 2 */
22691 {
22692 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
22693 malloc(sizeof(struct _ssSFcnModelMethods2));
22694 ss_VALIDATE_MEMORY(rts,methods2);
22695 ssSetModelMethods2(childS, methods2);
22696 }
22697
22698 /* Allocate memory of model methods 3 */
22699 {
22700 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
22701 malloc(sizeof(struct _ssSFcnModelMethods3));
22702 ss_VALIDATE_MEMORY(rts,methods3);
22703 ssSetModelMethods3(childS, methods3);
22704 }
22705
22706 /* Allocate memory for states auxilliary information */
22707 {
22708 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
22709 (sizeof(struct _ssStatesInfo2));
22710 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
22711 malloc(sizeof(ssPeriodicStatesInfo));
22712 ss_VALIDATE_MEMORY(rts,statesInfo2);
22713 ssSetStatesInfo2(childS, statesInfo2);
22714 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
22715 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
22716 }
22717
22718 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
22719 RegNumInputPorts);
22720 ssSetRegNumInputPortsFcnArg(childS,childS);
22721
22722 /* inputs */
22723 {
22724 struct _ssPortInputs *inputPortInfo =
22725 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
22726 ss_VALIDATE_MEMORY(rts,inputPortInfo);
22727 _ssSetNumInputPorts(childS, 2);
22728 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
22729
22730 /* port 0 */
22731 {
22732 real32_T const **sfcnUPtrs = (real32_T const **)
22733 malloc(1 * sizeof(real32_T *));
22734 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22735 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
22736 ssGetLocalBlockIO(rts))->GeneratedSFunction_fb;
22737 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
22738 _ssSetInputPortNumDimensions(childS, 0, 1);
22739 ssSetInputPortWidth(childS, 0, 1);
22740 }
22741
22742 /* port 1 */
22743 {
22744 real32_T const **sfcnUPtrs = (real32_T const **)
22745 malloc(1 * sizeof(real32_T *));
22746 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22747 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
22748 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
22749 _ssSetInputPortNumDimensions(childS, 1, 1);
22750 ssSetInputPortWidth(childS, 1, 1);
22751 }
22752 }
22753
22754 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
22755 RegNumOutputPorts);
22756 ssSetRegNumOutputPortsFcnArg(childS,childS);
22757
22758 /* outputs */
22759 {
22760 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
22761 calloc(1, sizeof(struct _ssPortOutputs));
22762 ss_VALIDATE_MEMORY(rts,outputPortInfo);
22763 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
22764 _ssSetNumOutputPorts(childS, 1);
22765
22766 /* port 0 */
22767 {
22768 _ssSetOutputPortNumDimensions(childS, 0, 1);
22769 ssSetOutputPortWidth(childS, 0, 1);
22770 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
22771 ssGetLocalBlockIO(rts))->GeneratedSFunction_ok));
22772 }
22773 }
22774
22775 /* path info */
22776 _ssSetModelName(childS, "Gain_sf");
22777 _ssSetPath(childS,
22778 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/gain4/Generated S-Function");
22779 if (ssGetRTModel(rts) == (NULL)) {
22780 _ssSetParentSS(childS, rts);
22781 _ssSetRootSS(childS, ssGetRootSS(rts));
22782 } else {
22783 ssSetRTModel(childS,ssGetRTModel(rts));
22784 _ssSetParentSS(childS, (NULL));
22785 _ssSetRootSS(childS, childS);
22786 }
22787
22788 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
22789 (childS)->regDataType.arg1 = ((void *)(childS));
22790 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
22791 FcnSetErrorStatus);
22792 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
22793 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
22794 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
22795 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
22796
22797 /* registration */
22798#if defined(MATLAB_MEX_FILE)
22799
22800 {
22801 int_T i;
22802 mxArray *plhs[1];
22803 mxArray *prhs[4];
22804 double *pr;
22805 volatile int_T *intS = (int_T *)&childS;
22806 int_T addrlen = sizeof(SimStruct *);
22807 int_T m = addrlen/sizeof(int_T) + 1;
22808 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
22809 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
22810 pr = mxGetPr(prhs[1]);
22811 for (i = 0; i < m - 1; i++) {
22812 pr[i] = (double)intS[i];
22813 }
22814
22815 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
22816 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
22817 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
22818
22819 /* Reset port dimensions info functions because the S-function
22820 * and accelerator mex-files explicitly set their dimensions,
22821 * i.e., they are not dynamically sized. For this case, the
22822 * mex-file is responsible for the dimensions info memory
22823 * and Simulink should not free it. This is achieved by
22824 * setting the following two methods to NULL.
22825 */
22826 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
22827 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
22828
22829 /*
22830 * Setup function pointers and call mdlInitializeSizes via
22831 * simulink.c
22832 */
22833 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
22834 mxDestroyArray(plhs[0]);
22835 mxDestroyArray(prhs[0]);
22836 mxDestroyArray(prhs[1]);
22837 mxDestroyArray(prhs[2]);
22838 mxDestroyArray(prhs[3]);
22839 }
22840
22841#else
22842
22843 {
22844 Gain_sf(childS);
22845 sfcnInitializeSizes(childS);
22846 }
22847
22848#endif
22849
22850 sfcnInitializeSampleTimes(childS);
22851
22852 /* adjust sample time */
22853 ssSetSampleTime(childS, 0, 0.0);
22854 ssSetOffsetTime(childS, 0, 0.0);
22855 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
22856
22857 /* set compiled values of dynamic vector attributes */
22858 ssSetNumNonsampledZCs(childS, 0);
22859
22860 /* Update connectivity flags for each port */
22861 _ssSetInputPortConnected(childS, 0, 1);
22862 _ssSetInputPortConnected(childS, 1, 1);
22863 _ssSetOutputPortConnected(childS, 0, 1);
22864 _ssSetOutputPortBeingMerged(childS, 0, 0);
22865
22866 /* Update the BufferDstPort flags for each input port */
22867 _ssSetInputPortBufferDstPort(childS, 0, -1);
22868 _ssSetInputPortBufferDstPort(childS, 1, -1);
22869 }
22870
22871 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S160>/Generated S-Function3 (IntegratorLimited_sf) */
22872 {
22873 SimStruct *childS = ssGetSFunction(rts, 86);
22874
22875 /* timing info */
22876 time_T *sfcnPeriod;
22877 time_T *sfcnOffset;
22878 int_T *sfcnTsMap;
22879 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
22880 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
22881 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
22882 ss_VALIDATE_MEMORY(rts,sfcnOffset);
22883 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
22884 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
22885 (void) memset((void*)sfcnPeriod, 0,
22886 sizeof(time_T)*1);
22887 (void) memset((void*)sfcnOffset, 0,
22888 sizeof(time_T)*1);
22889 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
22890 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
22891 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
22892
22893 /* Set up the mdlInfo pointer */
22894# ifdef USE_RTMODEL
22895
22896 {
22897 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
22898 struct _ssBlkInfo2));
22899 ss_VALIDATE_MEMORY(rts,blkInfo2);
22900 ssSetBlkInfo2Ptr(childS, blkInfo2);
22901 }
22902
22903 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
22904
22905# else
22906
22907 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
22908
22909# endif /* USE_RTMODEL */
22910
22911 /* Allocate memory of model methods 2 */
22912 {
22913 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
22914 malloc(sizeof(struct _ssSFcnModelMethods2));
22915 ss_VALIDATE_MEMORY(rts,methods2);
22916 ssSetModelMethods2(childS, methods2);
22917 }
22918
22919 /* Allocate memory of model methods 3 */
22920 {
22921 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
22922 malloc(sizeof(struct _ssSFcnModelMethods3));
22923 ss_VALIDATE_MEMORY(rts,methods3);
22924 ssSetModelMethods3(childS, methods3);
22925 }
22926
22927 /* Allocate memory for states auxilliary information */
22928 {
22929 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
22930 (sizeof(struct _ssStatesInfo2));
22931 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
22932 malloc(sizeof(ssPeriodicStatesInfo));
22933 ss_VALIDATE_MEMORY(rts,statesInfo2);
22934 ssSetStatesInfo2(childS, statesInfo2);
22935 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
22936 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
22937 }
22938
22939 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
22940 RegNumInputPorts);
22941 ssSetRegNumInputPortsFcnArg(childS,childS);
22942
22943 /* inputs */
22944 {
22945 struct _ssPortInputs *inputPortInfo =
22946 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
22947 ss_VALIDATE_MEMORY(rts,inputPortInfo);
22948 _ssSetNumInputPorts(childS, 7);
22949 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
22950
22951 /* port 0 */
22952 {
22953 real32_T const **sfcnUPtrs = (real32_T const **)
22954 malloc(1 * sizeof(real32_T *));
22955 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22956 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
22957 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
22958 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
22959 _ssSetInputPortNumDimensions(childS, 0, 1);
22960 ssSetInputPortWidth(childS, 0, 1);
22961 }
22962
22963 /* port 1 */
22964 {
22965 int8_T const **sfcnUPtrs = (int8_T const **)
22966 malloc(1 * sizeof(int8_T *));
22967 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22968 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
22969 ssGetLocalBlockIO(rts))->DataTypeConversion4_g;
22970 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
22971 _ssSetInputPortNumDimensions(childS, 1, 1);
22972 ssSetInputPortWidth(childS, 1, 1);
22973 }
22974
22975 /* port 2 */
22976 {
22977 real32_T const **sfcnUPtrs = (real32_T const **)
22978 malloc(1 * sizeof(real32_T *));
22979 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22980 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
22981 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
22982 _ssSetInputPortNumDimensions(childS, 2, 1);
22983 ssSetInputPortWidth(childS, 2, 1);
22984 }
22985
22986 /* port 3 */
22987 {
22988 real32_T const **sfcnUPtrs = (real32_T const **)
22989 malloc(1 * sizeof(real32_T *));
22990 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
22991 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
22992 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
22993 _ssSetInputPortNumDimensions(childS, 3, 1);
22994 ssSetInputPortWidth(childS, 3, 1);
22995 }
22996
22997 /* port 4 */
22998 {
22999 real32_T const **sfcnUPtrs = (real32_T const **)
23000 malloc(1 * sizeof(real32_T *));
23001 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23002 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled111;
23003 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
23004 _ssSetInputPortNumDimensions(childS, 4, 1);
23005 ssSetInputPortWidth(childS, 4, 1);
23006 }
23007
23008 /* port 5 */
23009 {
23010 real32_T const **sfcnUPtrs = (real32_T const **)
23011 malloc(1 * sizeof(real32_T *));
23012 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23013 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled112;
23014 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
23015 _ssSetInputPortNumDimensions(childS, 5, 1);
23016 ssSetInputPortWidth(childS, 5, 1);
23017 }
23018
23019 /* port 6 */
23020 {
23021 real32_T const **sfcnUPtrs = (real32_T const **)
23022 malloc(1 * sizeof(real32_T *));
23023 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23024 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
23025 ssGetLocalBlockIO(rts))->GeneratedSFunction_ok;
23026 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
23027 _ssSetInputPortNumDimensions(childS, 6, 1);
23028 ssSetInputPortWidth(childS, 6, 1);
23029 }
23030 }
23031
23032 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
23033 RegNumOutputPorts);
23034 ssSetRegNumOutputPortsFcnArg(childS,childS);
23035
23036 /* outputs */
23037 {
23038 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
23039 calloc(1, sizeof(struct _ssPortOutputs));
23040 ss_VALIDATE_MEMORY(rts,outputPortInfo);
23041 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
23042 _ssSetNumOutputPorts(childS, 1);
23043
23044 /* port 0 */
23045 {
23046 _ssSetOutputPortNumDimensions(childS, 0, 1);
23047 ssSetOutputPortWidth(childS, 0, 1);
23048 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
23049 ssGetLocalBlockIO(rts))->Saturation2_p));
23050 }
23051 }
23052
23053 /* path info */
23054 _ssSetModelName(childS, "IntegratorLimited_sf");
23055 _ssSetPath(childS,
23056 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Integrator Limited1/Generated S-Function3");
23057 if (ssGetRTModel(rts) == (NULL)) {
23058 _ssSetParentSS(childS, rts);
23059 _ssSetRootSS(childS, ssGetRootSS(rts));
23060 } else {
23061 ssSetRTModel(childS,ssGetRTModel(rts));
23062 _ssSetParentSS(childS, (NULL));
23063 _ssSetRootSS(childS, childS);
23064 }
23065
23066 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
23067
23068 /* work vectors */
23069 {
23070 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
23071 (4 * sizeof(struct _ssDWorkRecord));
23072 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
23073 calloc(4, sizeof(struct _ssDWorkAuxRecord));
23074 ss_VALIDATE_MEMORY(rts,dWorkRecord);
23075 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
23076 ssSetSFcnDWork(childS, dWorkRecord);
23077 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
23078 _ssSetNumDWork(childS, 4);
23079
23080 /* DWORK0 */
23081 ssSetDWorkWidth(childS, 0, 1);
23082 ssSetDWorkDataType(childS, 0,SS_SINGLE);
23083 ssSetDWorkComplexSignal(childS, 0, 0);
23084 ssSetDWorkUsedAsDState(childS, 0, 1);
23085 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 214))[0]);
23086
23087 /* DWORK1 */
23088 ssSetDWorkWidth(childS, 1, 1);
23089 ssSetDWorkDataType(childS, 1,SS_SINGLE);
23090 ssSetDWorkComplexSignal(childS, 1, 0);
23091 ssSetDWorkUsedAsDState(childS, 1, 1);
23092 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 215))[0]);
23093
23094 /* DWORK2 */
23095 ssSetDWorkWidth(childS, 2, 1);
23096 ssSetDWorkDataType(childS, 2,SS_INT8);
23097 ssSetDWorkComplexSignal(childS, 2, 0);
23098 ssSetDWorkUsedAsDState(childS, 2, 1);
23099 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 441))[0]);
23100
23101 /* DWORK3 */
23102 ssSetDWorkWidth(childS, 3, 1);
23103 ssSetDWorkDataType(childS, 3,SS_INT8);
23104 ssSetDWorkComplexSignal(childS, 3, 0);
23105 ssSetDWorkUsedAsDState(childS, 3, 1);
23106 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 442))[0]);
23107 }
23108
23109 (childS)->regDataType.arg1 = ((void *)(childS));
23110 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
23111 FcnSetErrorStatus);
23112 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
23113 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
23114 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
23115 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
23116
23117 /* registration */
23118#if defined(MATLAB_MEX_FILE)
23119
23120 {
23121 int_T i;
23122 mxArray *plhs[1];
23123 mxArray *prhs[4];
23124 double *pr;
23125 volatile int_T *intS = (int_T *)&childS;
23126 int_T addrlen = sizeof(SimStruct *);
23127 int_T m = addrlen/sizeof(int_T) + 1;
23128 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
23129 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
23130 pr = mxGetPr(prhs[1]);
23131 for (i = 0; i < m - 1; i++) {
23132 pr[i] = (double)intS[i];
23133 }
23134
23135 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
23136 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
23137 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
23138
23139 /* Reset port dimensions info functions because the S-function
23140 * and accelerator mex-files explicitly set their dimensions,
23141 * i.e., they are not dynamically sized. For this case, the
23142 * mex-file is responsible for the dimensions info memory
23143 * and Simulink should not free it. This is achieved by
23144 * setting the following two methods to NULL.
23145 */
23146 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
23147 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
23148
23149 /*
23150 * Setup function pointers and call mdlInitializeSizes via
23151 * simulink.c
23152 */
23153 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
23154 mxDestroyArray(plhs[0]);
23155 mxDestroyArray(prhs[0]);
23156 mxDestroyArray(prhs[1]);
23157 mxDestroyArray(prhs[2]);
23158 mxDestroyArray(prhs[3]);
23159 }
23160
23161#else
23162
23163 {
23164 IntegratorLimited_sf(childS);
23165 sfcnInitializeSizes(childS);
23166 }
23167
23168#endif
23169
23170 sfcnInitializeSampleTimes(childS);
23171
23172 /* adjust sample time */
23173 ssSetSampleTime(childS, 0, 0.0);
23174 ssSetOffsetTime(childS, 0, 0.0);
23175 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
23176
23177 /* set compiled values of dynamic vector attributes */
23178 ssSetNumNonsampledZCs(childS, 0);
23179
23180 /* Update connectivity flags for each port */
23181 _ssSetInputPortConnected(childS, 0, 1);
23182 _ssSetInputPortConnected(childS, 1, 1);
23183 _ssSetInputPortConnected(childS, 2, 1);
23184 _ssSetInputPortConnected(childS, 3, 1);
23185 _ssSetInputPortConnected(childS, 4, 1);
23186 _ssSetInputPortConnected(childS, 5, 1);
23187 _ssSetInputPortConnected(childS, 6, 1);
23188 _ssSetOutputPortConnected(childS, 0, 1);
23189 _ssSetOutputPortBeingMerged(childS, 0, 0);
23190
23191 /* Update the BufferDstPort flags for each input port */
23192 _ssSetInputPortBufferDstPort(childS, 0, -1);
23193 _ssSetInputPortBufferDstPort(childS, 1, -1);
23194 _ssSetInputPortBufferDstPort(childS, 2, -1);
23195 _ssSetInputPortBufferDstPort(childS, 3, -1);
23196 _ssSetInputPortBufferDstPort(childS, 4, -1);
23197 _ssSetInputPortBufferDstPort(childS, 5, -1);
23198 _ssSetInputPortBufferDstPort(childS, 6, -1);
23199 }
23200
23201 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S129>/Generated S-Function6 (Res180_sf) */
23202 {
23203 SimStruct *childS = ssGetSFunction(rts, 87);
23204
23205 /* timing info */
23206 time_T *sfcnPeriod;
23207 time_T *sfcnOffset;
23208 int_T *sfcnTsMap;
23209 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
23210 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
23211 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
23212 ss_VALIDATE_MEMORY(rts,sfcnOffset);
23213 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
23214 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
23215 (void) memset((void*)sfcnPeriod, 0,
23216 sizeof(time_T)*1);
23217 (void) memset((void*)sfcnOffset, 0,
23218 sizeof(time_T)*1);
23219 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
23220 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
23221 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
23222
23223 /* Set up the mdlInfo pointer */
23224# ifdef USE_RTMODEL
23225
23226 {
23227 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
23228 struct _ssBlkInfo2));
23229 ss_VALIDATE_MEMORY(rts,blkInfo2);
23230 ssSetBlkInfo2Ptr(childS, blkInfo2);
23231 }
23232
23233 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
23234
23235# else
23236
23237 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
23238
23239# endif /* USE_RTMODEL */
23240
23241 /* Allocate memory of model methods 2 */
23242 {
23243 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
23244 malloc(sizeof(struct _ssSFcnModelMethods2));
23245 ss_VALIDATE_MEMORY(rts,methods2);
23246 ssSetModelMethods2(childS, methods2);
23247 }
23248
23249 /* Allocate memory of model methods 3 */
23250 {
23251 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
23252 malloc(sizeof(struct _ssSFcnModelMethods3));
23253 ss_VALIDATE_MEMORY(rts,methods3);
23254 ssSetModelMethods3(childS, methods3);
23255 }
23256
23257 /* Allocate memory for states auxilliary information */
23258 {
23259 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
23260 (sizeof(struct _ssStatesInfo2));
23261 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
23262 malloc(sizeof(ssPeriodicStatesInfo));
23263 ss_VALIDATE_MEMORY(rts,statesInfo2);
23264 ssSetStatesInfo2(childS, statesInfo2);
23265 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
23266 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
23267 }
23268
23269 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
23270 RegNumInputPorts);
23271 ssSetRegNumInputPortsFcnArg(childS,childS);
23272
23273 /* inputs */
23274 {
23275 struct _ssPortInputs *inputPortInfo =
23276 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
23277 ss_VALIDATE_MEMORY(rts,inputPortInfo);
23278 _ssSetNumInputPorts(childS, 1);
23279 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
23280
23281 /* port 0 */
23282 {
23283 real32_T const **sfcnUPtrs = (real32_T const **)
23284 malloc(1 * sizeof(real32_T *));
23285 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23286 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
23287 ssGetLocalBlockIO(rts))->Sum3_cy;
23288 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
23289 _ssSetInputPortNumDimensions(childS, 0, 1);
23290 ssSetInputPortWidth(childS, 0, 1);
23291 }
23292 }
23293
23294 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
23295 RegNumOutputPorts);
23296 ssSetRegNumOutputPortsFcnArg(childS,childS);
23297
23298 /* outputs */
23299 {
23300 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
23301 calloc(1, sizeof(struct _ssPortOutputs));
23302 ss_VALIDATE_MEMORY(rts,outputPortInfo);
23303 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
23304 _ssSetNumOutputPorts(childS, 1);
23305
23306 /* port 0 */
23307 {
23308 _ssSetOutputPortNumDimensions(childS, 0, 1);
23309 ssSetOutputPortWidth(childS, 0, 1);
23310 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
23311 ssGetLocalBlockIO(rts))->GeneratedSFunction6_h3));
23312 }
23313 }
23314
23315 /* path info */
23316 _ssSetModelName(childS, "Res180_sf");
23317 _ssSetPath(childS,
23318 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Generated S-Function6");
23319 if (ssGetRTModel(rts) == (NULL)) {
23320 _ssSetParentSS(childS, rts);
23321 _ssSetRootSS(childS, ssGetRootSS(rts));
23322 } else {
23323 ssSetRTModel(childS,ssGetRTModel(rts));
23324 _ssSetParentSS(childS, (NULL));
23325 _ssSetRootSS(childS, childS);
23326 }
23327
23328 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
23329 (childS)->regDataType.arg1 = ((void *)(childS));
23330 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
23331 FcnSetErrorStatus);
23332 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
23333 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
23334 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
23335 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
23336
23337 /* registration */
23338#if defined(MATLAB_MEX_FILE)
23339
23340 {
23341 int_T i;
23342 mxArray *plhs[1];
23343 mxArray *prhs[4];
23344 double *pr;
23345 volatile int_T *intS = (int_T *)&childS;
23346 int_T addrlen = sizeof(SimStruct *);
23347 int_T m = addrlen/sizeof(int_T) + 1;
23348 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
23349 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
23350 pr = mxGetPr(prhs[1]);
23351 for (i = 0; i < m - 1; i++) {
23352 pr[i] = (double)intS[i];
23353 }
23354
23355 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
23356 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
23357 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
23358
23359 /* Reset port dimensions info functions because the S-function
23360 * and accelerator mex-files explicitly set their dimensions,
23361 * i.e., they are not dynamically sized. For this case, the
23362 * mex-file is responsible for the dimensions info memory
23363 * and Simulink should not free it. This is achieved by
23364 * setting the following two methods to NULL.
23365 */
23366 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
23367 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
23368
23369 /*
23370 * Setup function pointers and call mdlInitializeSizes via
23371 * simulink.c
23372 */
23373 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
23374 mxDestroyArray(plhs[0]);
23375 mxDestroyArray(prhs[0]);
23376 mxDestroyArray(prhs[1]);
23377 mxDestroyArray(prhs[2]);
23378 mxDestroyArray(prhs[3]);
23379 }
23380
23381#else
23382
23383 {
23384 Res180_sf(childS);
23385 sfcnInitializeSizes(childS);
23386 }
23387
23388#endif
23389
23390 sfcnInitializeSampleTimes(childS);
23391
23392 /* adjust sample time */
23393 ssSetSampleTime(childS, 0, 0.0);
23394 ssSetOffsetTime(childS, 0, 0.0);
23395 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
23396
23397 /* set compiled values of dynamic vector attributes */
23398 ssSetNumNonsampledZCs(childS, 0);
23399
23400 /* Update connectivity flags for each port */
23401 _ssSetInputPortConnected(childS, 0, 1);
23402 _ssSetOutputPortConnected(childS, 0, 1);
23403 _ssSetOutputPortBeingMerged(childS, 0, 0);
23404
23405 /* Update the BufferDstPort flags for each input port */
23406 _ssSetInputPortBufferDstPort(childS, 0, -1);
23407 }
23408
23409 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S162>/Generated S-Function1 (SaturationLimiter_sf) */
23410 {
23411 SimStruct *childS = ssGetSFunction(rts, 88);
23412
23413 /* timing info */
23414 time_T *sfcnPeriod;
23415 time_T *sfcnOffset;
23416 int_T *sfcnTsMap;
23417 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
23418 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
23419 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
23420 ss_VALIDATE_MEMORY(rts,sfcnOffset);
23421 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
23422 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
23423 (void) memset((void*)sfcnPeriod, 0,
23424 sizeof(time_T)*1);
23425 (void) memset((void*)sfcnOffset, 0,
23426 sizeof(time_T)*1);
23427 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
23428 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
23429 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
23430
23431 /* Set up the mdlInfo pointer */
23432# ifdef USE_RTMODEL
23433
23434 {
23435 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
23436 struct _ssBlkInfo2));
23437 ss_VALIDATE_MEMORY(rts,blkInfo2);
23438 ssSetBlkInfo2Ptr(childS, blkInfo2);
23439 }
23440
23441 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
23442
23443# else
23444
23445 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
23446
23447# endif /* USE_RTMODEL */
23448
23449 /* Allocate memory of model methods 2 */
23450 {
23451 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
23452 malloc(sizeof(struct _ssSFcnModelMethods2));
23453 ss_VALIDATE_MEMORY(rts,methods2);
23454 ssSetModelMethods2(childS, methods2);
23455 }
23456
23457 /* Allocate memory of model methods 3 */
23458 {
23459 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
23460 malloc(sizeof(struct _ssSFcnModelMethods3));
23461 ss_VALIDATE_MEMORY(rts,methods3);
23462 ssSetModelMethods3(childS, methods3);
23463 }
23464
23465 /* Allocate memory for states auxilliary information */
23466 {
23467 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
23468 (sizeof(struct _ssStatesInfo2));
23469 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
23470 malloc(sizeof(ssPeriodicStatesInfo));
23471 ss_VALIDATE_MEMORY(rts,statesInfo2);
23472 ssSetStatesInfo2(childS, statesInfo2);
23473 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
23474 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
23475 }
23476
23477 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
23478 RegNumInputPorts);
23479 ssSetRegNumInputPortsFcnArg(childS,childS);
23480
23481 /* inputs */
23482 {
23483 struct _ssPortInputs *inputPortInfo =
23484 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
23485 ss_VALIDATE_MEMORY(rts,inputPortInfo);
23486 _ssSetNumInputPorts(childS, 3);
23487 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
23488
23489 /* port 0 */
23490 {
23491 real32_T const **sfcnUPtrs = (real32_T const **)
23492 malloc(1 * sizeof(real32_T *));
23493 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23494 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
23495 ssGetLocalBlockIO(rts))->GeneratedSFunction6_h3;
23496 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
23497 _ssSetInputPortNumDimensions(childS, 0, 1);
23498 ssSetInputPortWidth(childS, 0, 1);
23499 }
23500
23501 /* port 1 */
23502 {
23503 real32_T const **sfcnUPtrs = (real32_T const **)
23504 malloc(1 * sizeof(real32_T *));
23505 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23506 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
23507 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
23508 _ssSetInputPortNumDimensions(childS, 1, 1);
23509 ssSetInputPortWidth(childS, 1, 1);
23510 }
23511
23512 /* port 2 */
23513 {
23514 real32_T const **sfcnUPtrs = (real32_T const **)
23515 malloc(1 * sizeof(real32_T *));
23516 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23517 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;
23518 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
23519 _ssSetInputPortNumDimensions(childS, 2, 1);
23520 ssSetInputPortWidth(childS, 2, 1);
23521 }
23522 }
23523
23524 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
23525 RegNumOutputPorts);
23526 ssSetRegNumOutputPortsFcnArg(childS,childS);
23527
23528 /* outputs */
23529 {
23530 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
23531 calloc(1, sizeof(struct _ssPortOutputs));
23532 ss_VALIDATE_MEMORY(rts,outputPortInfo);
23533 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
23534 _ssSetNumOutputPorts(childS, 1);
23535
23536 /* port 0 */
23537 {
23538 _ssSetOutputPortNumDimensions(childS, 0, 1);
23539 ssSetOutputPortWidth(childS, 0, 1);
23540 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
23541 ssGetLocalBlockIO(rts))->GeneratedSFunction1_oh));
23542 }
23543 }
23544
23545 /* path info */
23546 _ssSetModelName(childS, "SaturationLimiter_sf");
23547 _ssSetPath(childS,
23548 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter1/Generated S-Function1");
23549 if (ssGetRTModel(rts) == (NULL)) {
23550 _ssSetParentSS(childS, rts);
23551 _ssSetRootSS(childS, ssGetRootSS(rts));
23552 } else {
23553 ssSetRTModel(childS,ssGetRTModel(rts));
23554 _ssSetParentSS(childS, (NULL));
23555 _ssSetRootSS(childS, childS);
23556 }
23557
23558 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
23559 (childS)->regDataType.arg1 = ((void *)(childS));
23560 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
23561 FcnSetErrorStatus);
23562 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
23563 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
23564 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
23565 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
23566
23567 /* registration */
23568#if defined(MATLAB_MEX_FILE)
23569
23570 {
23571 int_T i;
23572 mxArray *plhs[1];
23573 mxArray *prhs[4];
23574 double *pr;
23575 volatile int_T *intS = (int_T *)&childS;
23576 int_T addrlen = sizeof(SimStruct *);
23577 int_T m = addrlen/sizeof(int_T) + 1;
23578 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
23579 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
23580 pr = mxGetPr(prhs[1]);
23581 for (i = 0; i < m - 1; i++) {
23582 pr[i] = (double)intS[i];
23583 }
23584
23585 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
23586 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
23587 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
23588
23589 /* Reset port dimensions info functions because the S-function
23590 * and accelerator mex-files explicitly set their dimensions,
23591 * i.e., they are not dynamically sized. For this case, the
23592 * mex-file is responsible for the dimensions info memory
23593 * and Simulink should not free it. This is achieved by
23594 * setting the following two methods to NULL.
23595 */
23596 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
23597 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
23598
23599 /*
23600 * Setup function pointers and call mdlInitializeSizes via
23601 * simulink.c
23602 */
23603 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
23604 mxDestroyArray(plhs[0]);
23605 mxDestroyArray(prhs[0]);
23606 mxDestroyArray(prhs[1]);
23607 mxDestroyArray(prhs[2]);
23608 mxDestroyArray(prhs[3]);
23609 }
23610
23611#else
23612
23613 {
23614 SaturationLimiter_sf(childS);
23615 sfcnInitializeSizes(childS);
23616 }
23617
23618#endif
23619
23620 sfcnInitializeSampleTimes(childS);
23621
23622 /* adjust sample time */
23623 ssSetSampleTime(childS, 0, 0.0);
23624 ssSetOffsetTime(childS, 0, 0.0);
23625 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
23626
23627 /* set compiled values of dynamic vector attributes */
23628 ssSetNumNonsampledZCs(childS, 0);
23629
23630 /* Update connectivity flags for each port */
23631 _ssSetInputPortConnected(childS, 0, 1);
23632 _ssSetInputPortConnected(childS, 1, 1);
23633 _ssSetInputPortConnected(childS, 2, 1);
23634 _ssSetOutputPortConnected(childS, 0, 1);
23635 _ssSetOutputPortBeingMerged(childS, 0, 0);
23636
23637 /* Update the BufferDstPort flags for each input port */
23638 _ssSetInputPortBufferDstPort(childS, 0, -1);
23639 _ssSetInputPortBufferDstPort(childS, 1, -1);
23640 _ssSetInputPortBufferDstPort(childS, 2, -1);
23641 }
23642
23643 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S167>/Generated S-Function (Gain_sf) */
23644 {
23645 SimStruct *childS = ssGetSFunction(rts, 89);
23646
23647 /* timing info */
23648 time_T *sfcnPeriod;
23649 time_T *sfcnOffset;
23650 int_T *sfcnTsMap;
23651 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
23652 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
23653 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
23654 ss_VALIDATE_MEMORY(rts,sfcnOffset);
23655 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
23656 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
23657 (void) memset((void*)sfcnPeriod, 0,
23658 sizeof(time_T)*1);
23659 (void) memset((void*)sfcnOffset, 0,
23660 sizeof(time_T)*1);
23661 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
23662 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
23663 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
23664
23665 /* Set up the mdlInfo pointer */
23666# ifdef USE_RTMODEL
23667
23668 {
23669 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
23670 struct _ssBlkInfo2));
23671 ss_VALIDATE_MEMORY(rts,blkInfo2);
23672 ssSetBlkInfo2Ptr(childS, blkInfo2);
23673 }
23674
23675 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
23676
23677# else
23678
23679 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
23680
23681# endif /* USE_RTMODEL */
23682
23683 /* Allocate memory of model methods 2 */
23684 {
23685 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
23686 malloc(sizeof(struct _ssSFcnModelMethods2));
23687 ss_VALIDATE_MEMORY(rts,methods2);
23688 ssSetModelMethods2(childS, methods2);
23689 }
23690
23691 /* Allocate memory of model methods 3 */
23692 {
23693 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
23694 malloc(sizeof(struct _ssSFcnModelMethods3));
23695 ss_VALIDATE_MEMORY(rts,methods3);
23696 ssSetModelMethods3(childS, methods3);
23697 }
23698
23699 /* Allocate memory for states auxilliary information */
23700 {
23701 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
23702 (sizeof(struct _ssStatesInfo2));
23703 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
23704 malloc(sizeof(ssPeriodicStatesInfo));
23705 ss_VALIDATE_MEMORY(rts,statesInfo2);
23706 ssSetStatesInfo2(childS, statesInfo2);
23707 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
23708 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
23709 }
23710
23711 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
23712 RegNumInputPorts);
23713 ssSetRegNumInputPortsFcnArg(childS,childS);
23714
23715 /* inputs */
23716 {
23717 struct _ssPortInputs *inputPortInfo =
23718 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
23719 ss_VALIDATE_MEMORY(rts,inputPortInfo);
23720 _ssSetNumInputPorts(childS, 2);
23721 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
23722
23723 /* port 0 */
23724 {
23725 real32_T const **sfcnUPtrs = (real32_T const **)
23726 malloc(1 * sizeof(real32_T *));
23727 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23728 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
23729 ssGetLocalBlockIO(rts))->GeneratedSFunction1_oh;
23730 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
23731 _ssSetInputPortNumDimensions(childS, 0, 1);
23732 ssSetInputPortWidth(childS, 0, 1);
23733 }
23734
23735 /* port 1 */
23736 {
23737 real32_T const **sfcnUPtrs = (real32_T const **)
23738 malloc(1 * sizeof(real32_T *));
23739 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23740 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
23741 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
23742 _ssSetInputPortNumDimensions(childS, 1, 1);
23743 ssSetInputPortWidth(childS, 1, 1);
23744 }
23745 }
23746
23747 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
23748 RegNumOutputPorts);
23749 ssSetRegNumOutputPortsFcnArg(childS,childS);
23750
23751 /* outputs */
23752 {
23753 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
23754 calloc(1, sizeof(struct _ssPortOutputs));
23755 ss_VALIDATE_MEMORY(rts,outputPortInfo);
23756 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
23757 _ssSetNumOutputPorts(childS, 1);
23758
23759 /* port 0 */
23760 {
23761 _ssSetOutputPortNumDimensions(childS, 0, 1);
23762 ssSetOutputPortWidth(childS, 0, 1);
23763 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
23764 ssGetLocalBlockIO(rts))->GeneratedSFunction_mc));
23765 }
23766 }
23767
23768 /* path info */
23769 _ssSetModelName(childS, "Gain_sf");
23770 _ssSetPath(childS,
23771 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/gain2/Generated S-Function");
23772 if (ssGetRTModel(rts) == (NULL)) {
23773 _ssSetParentSS(childS, rts);
23774 _ssSetRootSS(childS, ssGetRootSS(rts));
23775 } else {
23776 ssSetRTModel(childS,ssGetRTModel(rts));
23777 _ssSetParentSS(childS, (NULL));
23778 _ssSetRootSS(childS, childS);
23779 }
23780
23781 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
23782 (childS)->regDataType.arg1 = ((void *)(childS));
23783 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
23784 FcnSetErrorStatus);
23785 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
23786 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
23787 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
23788 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
23789
23790 /* registration */
23791#if defined(MATLAB_MEX_FILE)
23792
23793 {
23794 int_T i;
23795 mxArray *plhs[1];
23796 mxArray *prhs[4];
23797 double *pr;
23798 volatile int_T *intS = (int_T *)&childS;
23799 int_T addrlen = sizeof(SimStruct *);
23800 int_T m = addrlen/sizeof(int_T) + 1;
23801 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
23802 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
23803 pr = mxGetPr(prhs[1]);
23804 for (i = 0; i < m - 1; i++) {
23805 pr[i] = (double)intS[i];
23806 }
23807
23808 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
23809 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
23810 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
23811
23812 /* Reset port dimensions info functions because the S-function
23813 * and accelerator mex-files explicitly set their dimensions,
23814 * i.e., they are not dynamically sized. For this case, the
23815 * mex-file is responsible for the dimensions info memory
23816 * and Simulink should not free it. This is achieved by
23817 * setting the following two methods to NULL.
23818 */
23819 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
23820 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
23821
23822 /*
23823 * Setup function pointers and call mdlInitializeSizes via
23824 * simulink.c
23825 */
23826 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
23827 mxDestroyArray(plhs[0]);
23828 mxDestroyArray(prhs[0]);
23829 mxDestroyArray(prhs[1]);
23830 mxDestroyArray(prhs[2]);
23831 mxDestroyArray(prhs[3]);
23832 }
23833
23834#else
23835
23836 {
23837 Gain_sf(childS);
23838 sfcnInitializeSizes(childS);
23839 }
23840
23841#endif
23842
23843 sfcnInitializeSampleTimes(childS);
23844
23845 /* adjust sample time */
23846 ssSetSampleTime(childS, 0, 0.0);
23847 ssSetOffsetTime(childS, 0, 0.0);
23848 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
23849
23850 /* set compiled values of dynamic vector attributes */
23851 ssSetNumNonsampledZCs(childS, 0);
23852
23853 /* Update connectivity flags for each port */
23854 _ssSetInputPortConnected(childS, 0, 1);
23855 _ssSetInputPortConnected(childS, 1, 1);
23856 _ssSetOutputPortConnected(childS, 0, 1);
23857 _ssSetOutputPortBeingMerged(childS, 0, 0);
23858
23859 /* Update the BufferDstPort flags for each input port */
23860 _ssSetInputPortBufferDstPort(childS, 0, -1);
23861 _ssSetInputPortBufferDstPort(childS, 1, -1);
23862 }
23863
23864 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S161>/Generated S-Function1 (SaturationLimiter_sf) */
23865 {
23866 SimStruct *childS = ssGetSFunction(rts, 90);
23867
23868 /* timing info */
23869 time_T *sfcnPeriod;
23870 time_T *sfcnOffset;
23871 int_T *sfcnTsMap;
23872 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
23873 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
23874 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
23875 ss_VALIDATE_MEMORY(rts,sfcnOffset);
23876 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
23877 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
23878 (void) memset((void*)sfcnPeriod, 0,
23879 sizeof(time_T)*1);
23880 (void) memset((void*)sfcnOffset, 0,
23881 sizeof(time_T)*1);
23882 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
23883 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
23884 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
23885
23886 /* Set up the mdlInfo pointer */
23887# ifdef USE_RTMODEL
23888
23889 {
23890 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
23891 struct _ssBlkInfo2));
23892 ss_VALIDATE_MEMORY(rts,blkInfo2);
23893 ssSetBlkInfo2Ptr(childS, blkInfo2);
23894 }
23895
23896 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
23897
23898# else
23899
23900 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
23901
23902# endif /* USE_RTMODEL */
23903
23904 /* Allocate memory of model methods 2 */
23905 {
23906 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
23907 malloc(sizeof(struct _ssSFcnModelMethods2));
23908 ss_VALIDATE_MEMORY(rts,methods2);
23909 ssSetModelMethods2(childS, methods2);
23910 }
23911
23912 /* Allocate memory of model methods 3 */
23913 {
23914 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
23915 malloc(sizeof(struct _ssSFcnModelMethods3));
23916 ss_VALIDATE_MEMORY(rts,methods3);
23917 ssSetModelMethods3(childS, methods3);
23918 }
23919
23920 /* Allocate memory for states auxilliary information */
23921 {
23922 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
23923 (sizeof(struct _ssStatesInfo2));
23924 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
23925 malloc(sizeof(ssPeriodicStatesInfo));
23926 ss_VALIDATE_MEMORY(rts,statesInfo2);
23927 ssSetStatesInfo2(childS, statesInfo2);
23928 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
23929 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
23930 }
23931
23932 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
23933 RegNumInputPorts);
23934 ssSetRegNumInputPortsFcnArg(childS,childS);
23935
23936 /* inputs */
23937 {
23938 struct _ssPortInputs *inputPortInfo =
23939 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
23940 ss_VALIDATE_MEMORY(rts,inputPortInfo);
23941 _ssSetNumInputPorts(childS, 3);
23942 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
23943
23944 /* port 0 */
23945 {
23946 real32_T const **sfcnUPtrs = (real32_T const **)
23947 malloc(1 * sizeof(real32_T *));
23948 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23949 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
23950 ssGetLocalBlockIO(rts))->GeneratedSFunction_mc;
23951 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
23952 _ssSetInputPortNumDimensions(childS, 0, 1);
23953 ssSetInputPortWidth(childS, 0, 1);
23954 }
23955
23956 /* port 1 */
23957 {
23958 real32_T const **sfcnUPtrs = (real32_T const **)
23959 malloc(1 * sizeof(real32_T *));
23960 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23961 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
23962 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
23963 _ssSetInputPortNumDimensions(childS, 1, 1);
23964 ssSetInputPortWidth(childS, 1, 1);
23965 }
23966
23967 /* port 2 */
23968 {
23969 real32_T const **sfcnUPtrs = (real32_T const **)
23970 malloc(1 * sizeof(real32_T *));
23971 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
23972 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;
23973 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
23974 _ssSetInputPortNumDimensions(childS, 2, 1);
23975 ssSetInputPortWidth(childS, 2, 1);
23976 }
23977 }
23978
23979 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
23980 RegNumOutputPorts);
23981 ssSetRegNumOutputPortsFcnArg(childS,childS);
23982
23983 /* outputs */
23984 {
23985 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
23986 calloc(1, sizeof(struct _ssPortOutputs));
23987 ss_VALIDATE_MEMORY(rts,outputPortInfo);
23988 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
23989 _ssSetNumOutputPorts(childS, 1);
23990
23991 /* port 0 */
23992 {
23993 _ssSetOutputPortNumDimensions(childS, 0, 1);
23994 ssSetOutputPortWidth(childS, 0, 1);
23995 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
23996 ssGetLocalBlockIO(rts))->Saturation2_p));
23997 }
23998 }
23999
24000 /* path info */
24001 _ssSetModelName(childS, "SaturationLimiter_sf");
24002 _ssSetPath(childS,
24003 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter/Generated S-Function1");
24004 if (ssGetRTModel(rts) == (NULL)) {
24005 _ssSetParentSS(childS, rts);
24006 _ssSetRootSS(childS, ssGetRootSS(rts));
24007 } else {
24008 ssSetRTModel(childS,ssGetRTModel(rts));
24009 _ssSetParentSS(childS, (NULL));
24010 _ssSetRootSS(childS, childS);
24011 }
24012
24013 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
24014 (childS)->regDataType.arg1 = ((void *)(childS));
24015 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
24016 FcnSetErrorStatus);
24017 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
24018 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
24019 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
24020 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
24021
24022 /* registration */
24023#if defined(MATLAB_MEX_FILE)
24024
24025 {
24026 int_T i;
24027 mxArray *plhs[1];
24028 mxArray *prhs[4];
24029 double *pr;
24030 volatile int_T *intS = (int_T *)&childS;
24031 int_T addrlen = sizeof(SimStruct *);
24032 int_T m = addrlen/sizeof(int_T) + 1;
24033 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
24034 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
24035 pr = mxGetPr(prhs[1]);
24036 for (i = 0; i < m - 1; i++) {
24037 pr[i] = (double)intS[i];
24038 }
24039
24040 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
24041 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
24042 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
24043
24044 /* Reset port dimensions info functions because the S-function
24045 * and accelerator mex-files explicitly set their dimensions,
24046 * i.e., they are not dynamically sized. For this case, the
24047 * mex-file is responsible for the dimensions info memory
24048 * and Simulink should not free it. This is achieved by
24049 * setting the following two methods to NULL.
24050 */
24051 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
24052 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
24053
24054 /*
24055 * Setup function pointers and call mdlInitializeSizes via
24056 * simulink.c
24057 */
24058 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
24059 mxDestroyArray(plhs[0]);
24060 mxDestroyArray(prhs[0]);
24061 mxDestroyArray(prhs[1]);
24062 mxDestroyArray(prhs[2]);
24063 mxDestroyArray(prhs[3]);
24064 }
24065
24066#else
24067
24068 {
24069 SaturationLimiter_sf(childS);
24070 sfcnInitializeSizes(childS);
24071 }
24072
24073#endif
24074
24075 sfcnInitializeSampleTimes(childS);
24076
24077 /* adjust sample time */
24078 ssSetSampleTime(childS, 0, 0.0);
24079 ssSetOffsetTime(childS, 0, 0.0);
24080 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
24081
24082 /* set compiled values of dynamic vector attributes */
24083 ssSetNumNonsampledZCs(childS, 0);
24084
24085 /* Update connectivity flags for each port */
24086 _ssSetInputPortConnected(childS, 0, 1);
24087 _ssSetInputPortConnected(childS, 1, 1);
24088 _ssSetInputPortConnected(childS, 2, 1);
24089 _ssSetOutputPortConnected(childS, 0, 1);
24090 _ssSetOutputPortBeingMerged(childS, 0, 0);
24091
24092 /* Update the BufferDstPort flags for each input port */
24093 _ssSetInputPortBufferDstPort(childS, 0, -1);
24094 _ssSetInputPortBufferDstPort(childS, 1, -1);
24095 _ssSetInputPortBufferDstPort(childS, 2, -1);
24096 }
24097
24098 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S129>/Generated S-Function1 (Res180_sf) */
24099 {
24100 SimStruct *childS = ssGetSFunction(rts, 91);
24101
24102 /* timing info */
24103 time_T *sfcnPeriod;
24104 time_T *sfcnOffset;
24105 int_T *sfcnTsMap;
24106 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
24107 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
24108 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
24109 ss_VALIDATE_MEMORY(rts,sfcnOffset);
24110 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
24111 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
24112 (void) memset((void*)sfcnPeriod, 0,
24113 sizeof(time_T)*1);
24114 (void) memset((void*)sfcnOffset, 0,
24115 sizeof(time_T)*1);
24116 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
24117 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
24118 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
24119
24120 /* Set up the mdlInfo pointer */
24121# ifdef USE_RTMODEL
24122
24123 {
24124 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
24125 struct _ssBlkInfo2));
24126 ss_VALIDATE_MEMORY(rts,blkInfo2);
24127 ssSetBlkInfo2Ptr(childS, blkInfo2);
24128 }
24129
24130 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
24131
24132# else
24133
24134 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
24135
24136# endif /* USE_RTMODEL */
24137
24138 /* Allocate memory of model methods 2 */
24139 {
24140 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
24141 malloc(sizeof(struct _ssSFcnModelMethods2));
24142 ss_VALIDATE_MEMORY(rts,methods2);
24143 ssSetModelMethods2(childS, methods2);
24144 }
24145
24146 /* Allocate memory of model methods 3 */
24147 {
24148 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
24149 malloc(sizeof(struct _ssSFcnModelMethods3));
24150 ss_VALIDATE_MEMORY(rts,methods3);
24151 ssSetModelMethods3(childS, methods3);
24152 }
24153
24154 /* Allocate memory for states auxilliary information */
24155 {
24156 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
24157 (sizeof(struct _ssStatesInfo2));
24158 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
24159 malloc(sizeof(ssPeriodicStatesInfo));
24160 ss_VALIDATE_MEMORY(rts,statesInfo2);
24161 ssSetStatesInfo2(childS, statesInfo2);
24162 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
24163 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
24164 }
24165
24166 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
24167 RegNumInputPorts);
24168 ssSetRegNumInputPortsFcnArg(childS,childS);
24169
24170 /* inputs */
24171 {
24172 struct _ssPortInputs *inputPortInfo =
24173 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
24174 ss_VALIDATE_MEMORY(rts,inputPortInfo);
24175 _ssSetNumInputPorts(childS, 1);
24176 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
24177
24178 /* port 0 */
24179 {
24180 real32_T const **sfcnUPtrs = (real32_T const **)
24181 malloc(1 * sizeof(real32_T *));
24182 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24183 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
24184 ssGetLocalBlockIO(rts))->Sum1_lk;
24185 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
24186 _ssSetInputPortNumDimensions(childS, 0, 1);
24187 ssSetInputPortWidth(childS, 0, 1);
24188 }
24189 }
24190
24191 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
24192 RegNumOutputPorts);
24193 ssSetRegNumOutputPortsFcnArg(childS,childS);
24194
24195 /* outputs */
24196 {
24197 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
24198 calloc(1, sizeof(struct _ssPortOutputs));
24199 ss_VALIDATE_MEMORY(rts,outputPortInfo);
24200 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
24201 _ssSetNumOutputPorts(childS, 1);
24202
24203 /* port 0 */
24204 {
24205 _ssSetOutputPortNumDimensions(childS, 0, 1);
24206 ssSetOutputPortWidth(childS, 0, 1);
24207 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
24208 ssGetLocalBlockIO(rts))->GeneratedSFunction1_f));
24209 }
24210 }
24211
24212 /* path info */
24213 _ssSetModelName(childS, "Res180_sf");
24214 _ssSetPath(childS,
24215 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Generated S-Function1");
24216 if (ssGetRTModel(rts) == (NULL)) {
24217 _ssSetParentSS(childS, rts);
24218 _ssSetRootSS(childS, ssGetRootSS(rts));
24219 } else {
24220 ssSetRTModel(childS,ssGetRTModel(rts));
24221 _ssSetParentSS(childS, (NULL));
24222 _ssSetRootSS(childS, childS);
24223 }
24224
24225 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
24226 (childS)->regDataType.arg1 = ((void *)(childS));
24227 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
24228 FcnSetErrorStatus);
24229 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
24230 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
24231 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
24232 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
24233
24234 /* registration */
24235#if defined(MATLAB_MEX_FILE)
24236
24237 {
24238 int_T i;
24239 mxArray *plhs[1];
24240 mxArray *prhs[4];
24241 double *pr;
24242 volatile int_T *intS = (int_T *)&childS;
24243 int_T addrlen = sizeof(SimStruct *);
24244 int_T m = addrlen/sizeof(int_T) + 1;
24245 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
24246 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
24247 pr = mxGetPr(prhs[1]);
24248 for (i = 0; i < m - 1; i++) {
24249 pr[i] = (double)intS[i];
24250 }
24251
24252 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
24253 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
24254 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
24255
24256 /* Reset port dimensions info functions because the S-function
24257 * and accelerator mex-files explicitly set their dimensions,
24258 * i.e., they are not dynamically sized. For this case, the
24259 * mex-file is responsible for the dimensions info memory
24260 * and Simulink should not free it. This is achieved by
24261 * setting the following two methods to NULL.
24262 */
24263 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
24264 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
24265
24266 /*
24267 * Setup function pointers and call mdlInitializeSizes via
24268 * simulink.c
24269 */
24270 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
24271 mxDestroyArray(plhs[0]);
24272 mxDestroyArray(prhs[0]);
24273 mxDestroyArray(prhs[1]);
24274 mxDestroyArray(prhs[2]);
24275 mxDestroyArray(prhs[3]);
24276 }
24277
24278#else
24279
24280 {
24281 Res180_sf(childS);
24282 sfcnInitializeSizes(childS);
24283 }
24284
24285#endif
24286
24287 sfcnInitializeSampleTimes(childS);
24288
24289 /* adjust sample time */
24290 ssSetSampleTime(childS, 0, 0.0);
24291 ssSetOffsetTime(childS, 0, 0.0);
24292 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
24293
24294 /* set compiled values of dynamic vector attributes */
24295 ssSetNumNonsampledZCs(childS, 0);
24296
24297 /* Update connectivity flags for each port */
24298 _ssSetInputPortConnected(childS, 0, 1);
24299 _ssSetOutputPortConnected(childS, 0, 1);
24300 _ssSetOutputPortBeingMerged(childS, 0, 0);
24301
24302 /* Update the BufferDstPort flags for each input port */
24303 _ssSetInputPortBufferDstPort(childS, 0, -1);
24304 }
24305
24306 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S166>/Generated S-Function (Gain_sf) */
24307 {
24308 SimStruct *childS = ssGetSFunction(rts, 92);
24309
24310 /* timing info */
24311 time_T *sfcnPeriod;
24312 time_T *sfcnOffset;
24313 int_T *sfcnTsMap;
24314 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
24315 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
24316 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
24317 ss_VALIDATE_MEMORY(rts,sfcnOffset);
24318 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
24319 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
24320 (void) memset((void*)sfcnPeriod, 0,
24321 sizeof(time_T)*1);
24322 (void) memset((void*)sfcnOffset, 0,
24323 sizeof(time_T)*1);
24324 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
24325 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
24326 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
24327
24328 /* Set up the mdlInfo pointer */
24329# ifdef USE_RTMODEL
24330
24331 {
24332 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
24333 struct _ssBlkInfo2));
24334 ss_VALIDATE_MEMORY(rts,blkInfo2);
24335 ssSetBlkInfo2Ptr(childS, blkInfo2);
24336 }
24337
24338 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
24339
24340# else
24341
24342 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
24343
24344# endif /* USE_RTMODEL */
24345
24346 /* Allocate memory of model methods 2 */
24347 {
24348 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
24349 malloc(sizeof(struct _ssSFcnModelMethods2));
24350 ss_VALIDATE_MEMORY(rts,methods2);
24351 ssSetModelMethods2(childS, methods2);
24352 }
24353
24354 /* Allocate memory of model methods 3 */
24355 {
24356 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
24357 malloc(sizeof(struct _ssSFcnModelMethods3));
24358 ss_VALIDATE_MEMORY(rts,methods3);
24359 ssSetModelMethods3(childS, methods3);
24360 }
24361
24362 /* Allocate memory for states auxilliary information */
24363 {
24364 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
24365 (sizeof(struct _ssStatesInfo2));
24366 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
24367 malloc(sizeof(ssPeriodicStatesInfo));
24368 ss_VALIDATE_MEMORY(rts,statesInfo2);
24369 ssSetStatesInfo2(childS, statesInfo2);
24370 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
24371 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
24372 }
24373
24374 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
24375 RegNumInputPorts);
24376 ssSetRegNumInputPortsFcnArg(childS,childS);
24377
24378 /* inputs */
24379 {
24380 struct _ssPortInputs *inputPortInfo =
24381 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
24382 ss_VALIDATE_MEMORY(rts,inputPortInfo);
24383 _ssSetNumInputPorts(childS, 2);
24384 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
24385
24386 /* port 0 */
24387 {
24388 real32_T const **sfcnUPtrs = (real32_T const **)
24389 malloc(1 * sizeof(real32_T *));
24390 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24391 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
24392 ssGetLocalBlockIO(rts))->GeneratedSFunction1_f;
24393 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
24394 _ssSetInputPortNumDimensions(childS, 0, 1);
24395 ssSetInputPortWidth(childS, 0, 1);
24396 }
24397
24398 /* port 1 */
24399 {
24400 real32_T const **sfcnUPtrs = (real32_T const **)
24401 malloc(1 * sizeof(real32_T *));
24402 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24403 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
24404 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
24405 _ssSetInputPortNumDimensions(childS, 1, 1);
24406 ssSetInputPortWidth(childS, 1, 1);
24407 }
24408 }
24409
24410 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
24411 RegNumOutputPorts);
24412 ssSetRegNumOutputPortsFcnArg(childS,childS);
24413
24414 /* outputs */
24415 {
24416 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
24417 calloc(1, sizeof(struct _ssPortOutputs));
24418 ss_VALIDATE_MEMORY(rts,outputPortInfo);
24419 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
24420 _ssSetNumOutputPorts(childS, 1);
24421
24422 /* port 0 */
24423 {
24424 _ssSetOutputPortNumDimensions(childS, 0, 1);
24425 ssSetOutputPortWidth(childS, 0, 1);
24426 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
24427 ssGetLocalBlockIO(rts))->Saturation2_p));
24428 }
24429 }
24430
24431 /* path info */
24432 _ssSetModelName(childS, "Gain_sf");
24433 _ssSetPath(childS,
24434 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/gain/Generated S-Function");
24435 if (ssGetRTModel(rts) == (NULL)) {
24436 _ssSetParentSS(childS, rts);
24437 _ssSetRootSS(childS, ssGetRootSS(rts));
24438 } else {
24439 ssSetRTModel(childS,ssGetRTModel(rts));
24440 _ssSetParentSS(childS, (NULL));
24441 _ssSetRootSS(childS, childS);
24442 }
24443
24444 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
24445 (childS)->regDataType.arg1 = ((void *)(childS));
24446 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
24447 FcnSetErrorStatus);
24448 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
24449 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
24450 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
24451 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
24452
24453 /* registration */
24454#if defined(MATLAB_MEX_FILE)
24455
24456 {
24457 int_T i;
24458 mxArray *plhs[1];
24459 mxArray *prhs[4];
24460 double *pr;
24461 volatile int_T *intS = (int_T *)&childS;
24462 int_T addrlen = sizeof(SimStruct *);
24463 int_T m = addrlen/sizeof(int_T) + 1;
24464 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
24465 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
24466 pr = mxGetPr(prhs[1]);
24467 for (i = 0; i < m - 1; i++) {
24468 pr[i] = (double)intS[i];
24469 }
24470
24471 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
24472 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
24473 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
24474
24475 /* Reset port dimensions info functions because the S-function
24476 * and accelerator mex-files explicitly set their dimensions,
24477 * i.e., they are not dynamically sized. For this case, the
24478 * mex-file is responsible for the dimensions info memory
24479 * and Simulink should not free it. This is achieved by
24480 * setting the following two methods to NULL.
24481 */
24482 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
24483 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
24484
24485 /*
24486 * Setup function pointers and call mdlInitializeSizes via
24487 * simulink.c
24488 */
24489 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
24490 mxDestroyArray(plhs[0]);
24491 mxDestroyArray(prhs[0]);
24492 mxDestroyArray(prhs[1]);
24493 mxDestroyArray(prhs[2]);
24494 mxDestroyArray(prhs[3]);
24495 }
24496
24497#else
24498
24499 {
24500 Gain_sf(childS);
24501 sfcnInitializeSizes(childS);
24502 }
24503
24504#endif
24505
24506 sfcnInitializeSampleTimes(childS);
24507
24508 /* adjust sample time */
24509 ssSetSampleTime(childS, 0, 0.0);
24510 ssSetOffsetTime(childS, 0, 0.0);
24511 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
24512
24513 /* set compiled values of dynamic vector attributes */
24514 ssSetNumNonsampledZCs(childS, 0);
24515
24516 /* Update connectivity flags for each port */
24517 _ssSetInputPortConnected(childS, 0, 1);
24518 _ssSetInputPortConnected(childS, 1, 1);
24519 _ssSetOutputPortConnected(childS, 0, 1);
24520 _ssSetOutputPortBeingMerged(childS, 0, 0);
24521
24522 /* Update the BufferDstPort flags for each input port */
24523 _ssSetInputPortBufferDstPort(childS, 0, -1);
24524 _ssSetInputPortBufferDstPort(childS, 1, -1);
24525 }
24526
24527 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S159>/Generated S-Function4 (LagFilter_sf) */
24528 {
24529 SimStruct *childS = ssGetSFunction(rts, 93);
24530
24531 /* timing info */
24532 time_T *sfcnPeriod;
24533 time_T *sfcnOffset;
24534 int_T *sfcnTsMap;
24535 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
24536 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
24537 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
24538 ss_VALIDATE_MEMORY(rts,sfcnOffset);
24539 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
24540 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
24541 (void) memset((void*)sfcnPeriod, 0,
24542 sizeof(time_T)*1);
24543 (void) memset((void*)sfcnOffset, 0,
24544 sizeof(time_T)*1);
24545 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
24546 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
24547 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
24548
24549 /* Set up the mdlInfo pointer */
24550# ifdef USE_RTMODEL
24551
24552 {
24553 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
24554 struct _ssBlkInfo2));
24555 ss_VALIDATE_MEMORY(rts,blkInfo2);
24556 ssSetBlkInfo2Ptr(childS, blkInfo2);
24557 }
24558
24559 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
24560
24561# else
24562
24563 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
24564
24565# endif /* USE_RTMODEL */
24566
24567 /* Allocate memory of model methods 2 */
24568 {
24569 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
24570 malloc(sizeof(struct _ssSFcnModelMethods2));
24571 ss_VALIDATE_MEMORY(rts,methods2);
24572 ssSetModelMethods2(childS, methods2);
24573 }
24574
24575 /* Allocate memory of model methods 3 */
24576 {
24577 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
24578 malloc(sizeof(struct _ssSFcnModelMethods3));
24579 ss_VALIDATE_MEMORY(rts,methods3);
24580 ssSetModelMethods3(childS, methods3);
24581 }
24582
24583 /* Allocate memory for states auxilliary information */
24584 {
24585 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
24586 (sizeof(struct _ssStatesInfo2));
24587 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
24588 malloc(sizeof(ssPeriodicStatesInfo));
24589 ss_VALIDATE_MEMORY(rts,statesInfo2);
24590 ssSetStatesInfo2(childS, statesInfo2);
24591 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
24592 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
24593 }
24594
24595 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
24596 RegNumInputPorts);
24597 ssSetRegNumInputPortsFcnArg(childS,childS);
24598
24599 /* inputs */
24600 {
24601 struct _ssPortInputs *inputPortInfo =
24602 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
24603 ss_VALIDATE_MEMORY(rts,inputPortInfo);
24604 _ssSetNumInputPorts(childS, 6);
24605 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
24606
24607 /* port 0 */
24608 {
24609 real32_T const **sfcnUPtrs = (real32_T const **)
24610 malloc(1 * sizeof(real32_T *));
24611 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24612 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
24613 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
24614 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
24615 _ssSetInputPortNumDimensions(childS, 0, 1);
24616 ssSetInputPortWidth(childS, 0, 1);
24617 }
24618
24619 /* port 1 */
24620 {
24621 int8_T const **sfcnUPtrs = (int8_T const **)
24622 malloc(1 * sizeof(int8_T *));
24623 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24624 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
24625 ssGetLocalBlockIO(rts))->DataTypeConversion4_g;
24626 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
24627 _ssSetInputPortNumDimensions(childS, 1, 1);
24628 ssSetInputPortWidth(childS, 1, 1);
24629 }
24630
24631 /* port 2 */
24632 {
24633 real32_T const **sfcnUPtrs = (real32_T const **)
24634 malloc(1 * sizeof(real32_T *));
24635 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24636 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
24637 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
24638 _ssSetInputPortNumDimensions(childS, 2, 1);
24639 ssSetInputPortWidth(childS, 2, 1);
24640 }
24641
24642 /* port 3 */
24643 {
24644 real32_T const **sfcnUPtrs = (real32_T const **)
24645 malloc(1 * sizeof(real32_T *));
24646 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24647 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
24648 ssGetLocalBlockIO(rts))->Switch_bg;
24649 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
24650 _ssSetInputPortNumDimensions(childS, 3, 1);
24651 ssSetInputPortWidth(childS, 3, 1);
24652 }
24653
24654 /* port 4 */
24655 {
24656 real32_T const **sfcnUPtrs = (real32_T const **)
24657 malloc(1 * sizeof(real32_T *));
24658 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24659 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
24660 ssGetLocalBlockIO(rts))->Switch_bg;
24661 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
24662 _ssSetInputPortNumDimensions(childS, 4, 1);
24663 ssSetInputPortWidth(childS, 4, 1);
24664 }
24665
24666 /* port 5 */
24667 {
24668 real32_T const **sfcnUPtrs = (real32_T const **)
24669 malloc(1 * sizeof(real32_T *));
24670 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24671 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
24672 ssGetLocalBlockIO(rts))->Sum_oh;
24673 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
24674 _ssSetInputPortNumDimensions(childS, 5, 1);
24675 ssSetInputPortWidth(childS, 5, 1);
24676 }
24677 }
24678
24679 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
24680 RegNumOutputPorts);
24681 ssSetRegNumOutputPortsFcnArg(childS,childS);
24682
24683 /* outputs */
24684 {
24685 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
24686 calloc(1, sizeof(struct _ssPortOutputs));
24687 ss_VALIDATE_MEMORY(rts,outputPortInfo);
24688 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
24689 _ssSetNumOutputPorts(childS, 1);
24690
24691 /* port 0 */
24692 {
24693 _ssSetOutputPortNumDimensions(childS, 0, 1);
24694 ssSetOutputPortWidth(childS, 0, 1);
24695 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
24696 ssGetLocalBlockIO(rts))->GeneratedSFunction4_mj));
24697 }
24698 }
24699
24700 /* path info */
24701 _ssSetModelName(childS, "LagFilter_sf");
24702 _ssSetPath(childS,
24703 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/ lag filter/Generated S-Function4");
24704 if (ssGetRTModel(rts) == (NULL)) {
24705 _ssSetParentSS(childS, rts);
24706 _ssSetRootSS(childS, ssGetRootSS(rts));
24707 } else {
24708 ssSetRTModel(childS,ssGetRTModel(rts));
24709 _ssSetParentSS(childS, (NULL));
24710 _ssSetRootSS(childS, childS);
24711 }
24712
24713 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
24714
24715 /* work vectors */
24716 {
24717 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
24718 (4 * sizeof(struct _ssDWorkRecord));
24719 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
24720 calloc(4, sizeof(struct _ssDWorkAuxRecord));
24721 ss_VALIDATE_MEMORY(rts,dWorkRecord);
24722 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
24723 ssSetSFcnDWork(childS, dWorkRecord);
24724 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
24725 _ssSetNumDWork(childS, 4);
24726
24727 /* DWORK0 */
24728 ssSetDWorkWidth(childS, 0, 1);
24729 ssSetDWorkDataType(childS, 0,SS_SINGLE);
24730 ssSetDWorkComplexSignal(childS, 0, 0);
24731 ssSetDWorkUsedAsDState(childS, 0, 1);
24732 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 216))[0]);
24733
24734 /* DWORK1 */
24735 ssSetDWorkWidth(childS, 1, 1);
24736 ssSetDWorkDataType(childS, 1,SS_SINGLE);
24737 ssSetDWorkComplexSignal(childS, 1, 0);
24738 ssSetDWorkUsedAsDState(childS, 1, 1);
24739 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 217))[0]);
24740
24741 /* DWORK2 */
24742 ssSetDWorkWidth(childS, 2, 1);
24743 ssSetDWorkDataType(childS, 2,SS_INT8);
24744 ssSetDWorkComplexSignal(childS, 2, 0);
24745 ssSetDWorkUsedAsDState(childS, 2, 1);
24746 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 443))[0]);
24747
24748 /* DWORK3 */
24749 ssSetDWorkWidth(childS, 3, 1);
24750 ssSetDWorkDataType(childS, 3,SS_INT8);
24751 ssSetDWorkComplexSignal(childS, 3, 0);
24752 ssSetDWorkUsedAsDState(childS, 3, 1);
24753 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 444))[0]);
24754 }
24755
24756 (childS)->regDataType.arg1 = ((void *)(childS));
24757 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
24758 FcnSetErrorStatus);
24759 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
24760 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
24761 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
24762 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
24763
24764 /* registration */
24765#if defined(MATLAB_MEX_FILE)
24766
24767 {
24768 int_T i;
24769 mxArray *plhs[1];
24770 mxArray *prhs[4];
24771 double *pr;
24772 volatile int_T *intS = (int_T *)&childS;
24773 int_T addrlen = sizeof(SimStruct *);
24774 int_T m = addrlen/sizeof(int_T) + 1;
24775 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
24776 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
24777 pr = mxGetPr(prhs[1]);
24778 for (i = 0; i < m - 1; i++) {
24779 pr[i] = (double)intS[i];
24780 }
24781
24782 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
24783 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
24784 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
24785
24786 /* Reset port dimensions info functions because the S-function
24787 * and accelerator mex-files explicitly set their dimensions,
24788 * i.e., they are not dynamically sized. For this case, the
24789 * mex-file is responsible for the dimensions info memory
24790 * and Simulink should not free it. This is achieved by
24791 * setting the following two methods to NULL.
24792 */
24793 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
24794 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
24795
24796 /*
24797 * Setup function pointers and call mdlInitializeSizes via
24798 * simulink.c
24799 */
24800 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
24801 mxDestroyArray(plhs[0]);
24802 mxDestroyArray(prhs[0]);
24803 mxDestroyArray(prhs[1]);
24804 mxDestroyArray(prhs[2]);
24805 mxDestroyArray(prhs[3]);
24806 }
24807
24808#else
24809
24810 {
24811 LagFilter_sf(childS);
24812 sfcnInitializeSizes(childS);
24813 }
24814
24815#endif
24816
24817 sfcnInitializeSampleTimes(childS);
24818
24819 /* adjust sample time */
24820 ssSetSampleTime(childS, 0, 0.0);
24821 ssSetOffsetTime(childS, 0, 0.0);
24822 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
24823
24824 /* set compiled values of dynamic vector attributes */
24825 ssSetNumNonsampledZCs(childS, 0);
24826
24827 /* Update connectivity flags for each port */
24828 _ssSetInputPortConnected(childS, 0, 1);
24829 _ssSetInputPortConnected(childS, 1, 1);
24830 _ssSetInputPortConnected(childS, 2, 1);
24831 _ssSetInputPortConnected(childS, 3, 1);
24832 _ssSetInputPortConnected(childS, 4, 1);
24833 _ssSetInputPortConnected(childS, 5, 1);
24834 _ssSetOutputPortConnected(childS, 0, 1);
24835 _ssSetOutputPortBeingMerged(childS, 0, 0);
24836
24837 /* Update the BufferDstPort flags for each input port */
24838 _ssSetInputPortBufferDstPort(childS, 0, -1);
24839 _ssSetInputPortBufferDstPort(childS, 1, -1);
24840 _ssSetInputPortBufferDstPort(childS, 2, -1);
24841 _ssSetInputPortBufferDstPort(childS, 3, -1);
24842 _ssSetInputPortBufferDstPort(childS, 4, -1);
24843 _ssSetInputPortBufferDstPort(childS, 5, -1);
24844 }
24845
24846 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S123>/Generated S-Function5 (Fader_sf) */
24847 {
24848 SimStruct *childS = ssGetSFunction(rts, 94);
24849
24850 /* timing info */
24851 time_T *sfcnPeriod;
24852 time_T *sfcnOffset;
24853 int_T *sfcnTsMap;
24854 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
24855 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
24856 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
24857 ss_VALIDATE_MEMORY(rts,sfcnOffset);
24858 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
24859 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
24860 (void) memset((void*)sfcnPeriod, 0,
24861 sizeof(time_T)*1);
24862 (void) memset((void*)sfcnOffset, 0,
24863 sizeof(time_T)*1);
24864 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
24865 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
24866 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
24867
24868 /* Set up the mdlInfo pointer */
24869# ifdef USE_RTMODEL
24870
24871 {
24872 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
24873 struct _ssBlkInfo2));
24874 ss_VALIDATE_MEMORY(rts,blkInfo2);
24875 ssSetBlkInfo2Ptr(childS, blkInfo2);
24876 }
24877
24878 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
24879
24880# else
24881
24882 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
24883
24884# endif /* USE_RTMODEL */
24885
24886 /* Allocate memory of model methods 2 */
24887 {
24888 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
24889 malloc(sizeof(struct _ssSFcnModelMethods2));
24890 ss_VALIDATE_MEMORY(rts,methods2);
24891 ssSetModelMethods2(childS, methods2);
24892 }
24893
24894 /* Allocate memory of model methods 3 */
24895 {
24896 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
24897 malloc(sizeof(struct _ssSFcnModelMethods3));
24898 ss_VALIDATE_MEMORY(rts,methods3);
24899 ssSetModelMethods3(childS, methods3);
24900 }
24901
24902 /* Allocate memory for states auxilliary information */
24903 {
24904 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
24905 (sizeof(struct _ssStatesInfo2));
24906 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
24907 malloc(sizeof(ssPeriodicStatesInfo));
24908 ss_VALIDATE_MEMORY(rts,statesInfo2);
24909 ssSetStatesInfo2(childS, statesInfo2);
24910 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
24911 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
24912 }
24913
24914 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
24915 RegNumInputPorts);
24916 ssSetRegNumInputPortsFcnArg(childS,childS);
24917
24918 /* inputs */
24919 {
24920 struct _ssPortInputs *inputPortInfo =
24921 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
24922 ss_VALIDATE_MEMORY(rts,inputPortInfo);
24923 _ssSetNumInputPorts(childS, 6);
24924 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
24925
24926 /* port 0 */
24927 {
24928 real32_T const **sfcnUPtrs = (real32_T const **)
24929 malloc(1 * sizeof(real32_T *));
24930 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24931 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
24932 ssGetLocalBlockIO(rts))->MultiportSwitch2_k;
24933 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
24934 _ssSetInputPortNumDimensions(childS, 0, 1);
24935 ssSetInputPortWidth(childS, 0, 1);
24936 }
24937
24938 /* port 1 */
24939 {
24940 real32_T const **sfcnUPtrs = (real32_T const **)
24941 malloc(1 * sizeof(real32_T *));
24942 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24943 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
24944 ssGetLocalBlockIO(rts))->MultiportSwitch2_k;
24945 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
24946 _ssSetInputPortNumDimensions(childS, 1, 1);
24947 ssSetInputPortWidth(childS, 1, 1);
24948 }
24949
24950 /* port 2 */
24951 {
24952 int8_T const **sfcnUPtrs = (int8_T const **)
24953 malloc(1 * sizeof(int8_T *));
24954 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24955 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
24956 ssGetLocalBlockIO(rts))->Switch9;
24957 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
24958 _ssSetInputPortNumDimensions(childS, 2, 1);
24959 ssSetInputPortWidth(childS, 2, 1);
24960 }
24961
24962 /* port 3 */
24963 {
24964 int8_T const **sfcnUPtrs = (int8_T const **)
24965 malloc(1 * sizeof(int8_T *));
24966 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24967 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
24968 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
24969 _ssSetInputPortNumDimensions(childS, 3, 1);
24970 ssSetInputPortWidth(childS, 3, 1);
24971 }
24972
24973 /* port 4 */
24974 {
24975 real32_T const **sfcnUPtrs = (real32_T const **)
24976 malloc(1 * sizeof(real32_T *));
24977 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24978 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
24979 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
24980 _ssSetInputPortNumDimensions(childS, 4, 1);
24981 ssSetInputPortWidth(childS, 4, 1);
24982 }
24983
24984 /* port 5 */
24985 {
24986 real32_T const **sfcnUPtrs = (real32_T const **)
24987 malloc(1 * sizeof(real32_T *));
24988 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
24989 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
24990 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
24991 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
24992 _ssSetInputPortNumDimensions(childS, 5, 1);
24993 ssSetInputPortWidth(childS, 5, 1);
24994 }
24995 }
24996
24997 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
24998 RegNumOutputPorts);
24999 ssSetRegNumOutputPortsFcnArg(childS,childS);
25000
25001 /* outputs */
25002 {
25003 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
25004 calloc(1, sizeof(struct _ssPortOutputs));
25005 ss_VALIDATE_MEMORY(rts,outputPortInfo);
25006 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
25007 _ssSetNumOutputPorts(childS, 1);
25008
25009 /* port 0 */
25010 {
25011 _ssSetOutputPortNumDimensions(childS, 0, 1);
25012 ssSetOutputPortWidth(childS, 0, 1);
25013 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
25014 ssGetLocalBlockIO(rts))->aprc));
25015 }
25016 }
25017
25018 /* path info */
25019 _ssSetModelName(childS, "Fader_sf");
25020 _ssSetPath(childS,
25021 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/Fader/Generated S-Function5");
25022 if (ssGetRTModel(rts) == (NULL)) {
25023 _ssSetParentSS(childS, rts);
25024 _ssSetRootSS(childS, ssGetRootSS(rts));
25025 } else {
25026 ssSetRTModel(childS,ssGetRTModel(rts));
25027 _ssSetParentSS(childS, (NULL));
25028 _ssSetRootSS(childS, childS);
25029 }
25030
25031 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
25032
25033 /* work vectors */
25034 {
25035 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
25036 (7 * sizeof(struct _ssDWorkRecord));
25037 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
25038 calloc(7, sizeof(struct _ssDWorkAuxRecord));
25039 ss_VALIDATE_MEMORY(rts,dWorkRecord);
25040 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
25041 ssSetSFcnDWork(childS, dWorkRecord);
25042 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
25043 _ssSetNumDWork(childS, 7);
25044
25045 /* DWORK0 */
25046 ssSetDWorkWidth(childS, 0, 1);
25047 ssSetDWorkDataType(childS, 0,SS_SINGLE);
25048 ssSetDWorkComplexSignal(childS, 0, 0);
25049 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 292))[0]);
25050
25051 /* DWORK1 */
25052 ssSetDWorkWidth(childS, 1, 1);
25053 ssSetDWorkDataType(childS, 1,SS_SINGLE);
25054 ssSetDWorkComplexSignal(childS, 1, 0);
25055 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 293))[0]);
25056
25057 /* DWORK2 */
25058 ssSetDWorkWidth(childS, 2, 1);
25059 ssSetDWorkDataType(childS, 2,SS_SINGLE);
25060 ssSetDWorkComplexSignal(childS, 2, 0);
25061 _ssSetDWork(childS, 2, &((real32_T*) ssGetDWork(rts, 294))[0]);
25062
25063 /* DWORK3 */
25064 ssSetDWorkWidth(childS, 3, 1);
25065 ssSetDWorkDataType(childS, 3,SS_INT32);
25066 ssSetDWorkComplexSignal(childS, 3, 0);
25067 _ssSetDWork(childS, 3, &((int32_T*) ssGetDWork(rts, 334))[0]);
25068
25069 /* DWORK4 */
25070 ssSetDWorkWidth(childS, 4, 1);
25071 ssSetDWorkDataType(childS, 4,SS_INT32);
25072 ssSetDWorkComplexSignal(childS, 4, 0);
25073 _ssSetDWork(childS, 4, &((int32_T*) ssGetDWork(rts, 335))[0]);
25074
25075 /* DWORK5 */
25076 ssSetDWorkWidth(childS, 5, 1);
25077 ssSetDWorkDataType(childS, 5,SS_INT8);
25078 ssSetDWorkComplexSignal(childS, 5, 0);
25079 _ssSetDWork(childS, 5, &((int8_T*) ssGetDWork(rts, 519))[0]);
25080
25081 /* DWORK6 */
25082 ssSetDWorkWidth(childS, 6, 1);
25083 ssSetDWorkDataType(childS, 6,SS_INT8);
25084 ssSetDWorkComplexSignal(childS, 6, 0);
25085 _ssSetDWork(childS, 6, &((int8_T*) ssGetDWork(rts, 520))[0]);
25086 }
25087
25088 (childS)->regDataType.arg1 = ((void *)(childS));
25089 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
25090 FcnSetErrorStatus);
25091 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
25092 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
25093 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
25094 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
25095
25096 /* registration */
25097#if defined(MATLAB_MEX_FILE)
25098
25099 {
25100 int_T i;
25101 mxArray *plhs[1];
25102 mxArray *prhs[4];
25103 double *pr;
25104 volatile int_T *intS = (int_T *)&childS;
25105 int_T addrlen = sizeof(SimStruct *);
25106 int_T m = addrlen/sizeof(int_T) + 1;
25107 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
25108 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
25109 pr = mxGetPr(prhs[1]);
25110 for (i = 0; i < m - 1; i++) {
25111 pr[i] = (double)intS[i];
25112 }
25113
25114 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
25115 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
25116 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
25117
25118 /* Reset port dimensions info functions because the S-function
25119 * and accelerator mex-files explicitly set their dimensions,
25120 * i.e., they are not dynamically sized. For this case, the
25121 * mex-file is responsible for the dimensions info memory
25122 * and Simulink should not free it. This is achieved by
25123 * setting the following two methods to NULL.
25124 */
25125 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
25126 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
25127
25128 /*
25129 * Setup function pointers and call mdlInitializeSizes via
25130 * simulink.c
25131 */
25132 mexCallMATLAB(1, plhs, 4, prhs, "Fader_sf");
25133 mxDestroyArray(plhs[0]);
25134 mxDestroyArray(prhs[0]);
25135 mxDestroyArray(prhs[1]);
25136 mxDestroyArray(prhs[2]);
25137 mxDestroyArray(prhs[3]);
25138 }
25139
25140#else
25141
25142 {
25143 Fader_sf(childS);
25144 sfcnInitializeSizes(childS);
25145 }
25146
25147#endif
25148
25149 sfcnInitializeSampleTimes(childS);
25150
25151 /* adjust sample time */
25152 ssSetSampleTime(childS, 0, 0.0);
25153 ssSetOffsetTime(childS, 0, 0.0);
25154 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
25155
25156 /* set compiled values of dynamic vector attributes */
25157 ssSetNumNonsampledZCs(childS, 0);
25158
25159 /* Update connectivity flags for each port */
25160 _ssSetInputPortConnected(childS, 0, 1);
25161 _ssSetInputPortConnected(childS, 1, 1);
25162 _ssSetInputPortConnected(childS, 2, 1);
25163 _ssSetInputPortConnected(childS, 3, 1);
25164 _ssSetInputPortConnected(childS, 4, 1);
25165 _ssSetInputPortConnected(childS, 5, 1);
25166 _ssSetOutputPortConnected(childS, 0, 1);
25167 _ssSetOutputPortBeingMerged(childS, 0, 0);
25168
25169 /* Update the BufferDstPort flags for each input port */
25170 _ssSetInputPortBufferDstPort(childS, 0, -1);
25171 _ssSetInputPortBufferDstPort(childS, 1, -1);
25172 _ssSetInputPortBufferDstPort(childS, 2, -1);
25173 _ssSetInputPortBufferDstPort(childS, 3, -1);
25174 _ssSetInputPortBufferDstPort(childS, 4, -1);
25175 _ssSetInputPortBufferDstPort(childS, 5, -1);
25176 }
25177
25178 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S163>/Generated S-Function1 (SaturationLimiter_sf) */
25179 {
25180 SimStruct *childS = ssGetSFunction(rts, 95);
25181
25182 /* timing info */
25183 time_T *sfcnPeriod;
25184 time_T *sfcnOffset;
25185 int_T *sfcnTsMap;
25186 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
25187 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
25188 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
25189 ss_VALIDATE_MEMORY(rts,sfcnOffset);
25190 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
25191 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
25192 (void) memset((void*)sfcnPeriod, 0,
25193 sizeof(time_T)*1);
25194 (void) memset((void*)sfcnOffset, 0,
25195 sizeof(time_T)*1);
25196 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
25197 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
25198 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
25199
25200 /* Set up the mdlInfo pointer */
25201# ifdef USE_RTMODEL
25202
25203 {
25204 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
25205 struct _ssBlkInfo2));
25206 ss_VALIDATE_MEMORY(rts,blkInfo2);
25207 ssSetBlkInfo2Ptr(childS, blkInfo2);
25208 }
25209
25210 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
25211
25212# else
25213
25214 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
25215
25216# endif /* USE_RTMODEL */
25217
25218 /* Allocate memory of model methods 2 */
25219 {
25220 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
25221 malloc(sizeof(struct _ssSFcnModelMethods2));
25222 ss_VALIDATE_MEMORY(rts,methods2);
25223 ssSetModelMethods2(childS, methods2);
25224 }
25225
25226 /* Allocate memory of model methods 3 */
25227 {
25228 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
25229 malloc(sizeof(struct _ssSFcnModelMethods3));
25230 ss_VALIDATE_MEMORY(rts,methods3);
25231 ssSetModelMethods3(childS, methods3);
25232 }
25233
25234 /* Allocate memory for states auxilliary information */
25235 {
25236 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
25237 (sizeof(struct _ssStatesInfo2));
25238 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
25239 malloc(sizeof(ssPeriodicStatesInfo));
25240 ss_VALIDATE_MEMORY(rts,statesInfo2);
25241 ssSetStatesInfo2(childS, statesInfo2);
25242 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
25243 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
25244 }
25245
25246 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
25247 RegNumInputPorts);
25248 ssSetRegNumInputPortsFcnArg(childS,childS);
25249
25250 /* inputs */
25251 {
25252 struct _ssPortInputs *inputPortInfo =
25253 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
25254 ss_VALIDATE_MEMORY(rts,inputPortInfo);
25255 _ssSetNumInputPorts(childS, 3);
25256 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
25257
25258 /* port 0 */
25259 {
25260 real32_T const **sfcnUPtrs = (real32_T const **)
25261 malloc(1 * sizeof(real32_T *));
25262 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25263 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
25264 ssGetLocalBlockIO(rts))->Divide_c2;
25265 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
25266 _ssSetInputPortNumDimensions(childS, 0, 1);
25267 ssSetInputPortWidth(childS, 0, 1);
25268 }
25269
25270 /* port 1 */
25271 {
25272 real32_T const **sfcnUPtrs = (real32_T const **)
25273 malloc(1 * sizeof(real32_T *));
25274 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25275 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
25276 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
25277 _ssSetInputPortNumDimensions(childS, 1, 1);
25278 ssSetInputPortWidth(childS, 1, 1);
25279 }
25280
25281 /* port 2 */
25282 {
25283 real32_T const **sfcnUPtrs = (real32_T const **)
25284 malloc(1 * sizeof(real32_T *));
25285 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25286 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;
25287 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
25288 _ssSetInputPortNumDimensions(childS, 2, 1);
25289 ssSetInputPortWidth(childS, 2, 1);
25290 }
25291 }
25292
25293 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
25294 RegNumOutputPorts);
25295 ssSetRegNumOutputPortsFcnArg(childS,childS);
25296
25297 /* outputs */
25298 {
25299 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
25300 calloc(1, sizeof(struct _ssPortOutputs));
25301 ss_VALIDATE_MEMORY(rts,outputPortInfo);
25302 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
25303 _ssSetNumOutputPorts(childS, 1);
25304
25305 /* port 0 */
25306 {
25307 _ssSetOutputPortNumDimensions(childS, 0, 1);
25308 ssSetOutputPortWidth(childS, 0, 1);
25309 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
25310 ssGetLocalBlockIO(rts))->GeneratedSFunction1_nk));
25311 }
25312 }
25313
25314 /* path info */
25315 _ssSetModelName(childS, "SaturationLimiter_sf");
25316 _ssSetPath(childS,
25317 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter2/Generated S-Function1");
25318 if (ssGetRTModel(rts) == (NULL)) {
25319 _ssSetParentSS(childS, rts);
25320 _ssSetRootSS(childS, ssGetRootSS(rts));
25321 } else {
25322 ssSetRTModel(childS,ssGetRTModel(rts));
25323 _ssSetParentSS(childS, (NULL));
25324 _ssSetRootSS(childS, childS);
25325 }
25326
25327 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
25328 (childS)->regDataType.arg1 = ((void *)(childS));
25329 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
25330 FcnSetErrorStatus);
25331 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
25332 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
25333 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
25334 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
25335
25336 /* registration */
25337#if defined(MATLAB_MEX_FILE)
25338
25339 {
25340 int_T i;
25341 mxArray *plhs[1];
25342 mxArray *prhs[4];
25343 double *pr;
25344 volatile int_T *intS = (int_T *)&childS;
25345 int_T addrlen = sizeof(SimStruct *);
25346 int_T m = addrlen/sizeof(int_T) + 1;
25347 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
25348 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
25349 pr = mxGetPr(prhs[1]);
25350 for (i = 0; i < m - 1; i++) {
25351 pr[i] = (double)intS[i];
25352 }
25353
25354 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
25355 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
25356 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
25357
25358 /* Reset port dimensions info functions because the S-function
25359 * and accelerator mex-files explicitly set their dimensions,
25360 * i.e., they are not dynamically sized. For this case, the
25361 * mex-file is responsible for the dimensions info memory
25362 * and Simulink should not free it. This is achieved by
25363 * setting the following two methods to NULL.
25364 */
25365 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
25366 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
25367
25368 /*
25369 * Setup function pointers and call mdlInitializeSizes via
25370 * simulink.c
25371 */
25372 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
25373 mxDestroyArray(plhs[0]);
25374 mxDestroyArray(prhs[0]);
25375 mxDestroyArray(prhs[1]);
25376 mxDestroyArray(prhs[2]);
25377 mxDestroyArray(prhs[3]);
25378 }
25379
25380#else
25381
25382 {
25383 SaturationLimiter_sf(childS);
25384 sfcnInitializeSizes(childS);
25385 }
25386
25387#endif
25388
25389 sfcnInitializeSampleTimes(childS);
25390
25391 /* adjust sample time */
25392 ssSetSampleTime(childS, 0, 0.005);
25393 ssSetOffsetTime(childS, 0, 0.0);
25394 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];
25395
25396 /* set compiled values of dynamic vector attributes */
25397 ssSetNumNonsampledZCs(childS, 0);
25398
25399 /* Update connectivity flags for each port */
25400 _ssSetInputPortConnected(childS, 0, 1);
25401 _ssSetInputPortConnected(childS, 1, 1);
25402 _ssSetInputPortConnected(childS, 2, 1);
25403 _ssSetOutputPortConnected(childS, 0, 1);
25404 _ssSetOutputPortBeingMerged(childS, 0, 0);
25405
25406 /* Update the BufferDstPort flags for each input port */
25407 _ssSetInputPortBufferDstPort(childS, 0, -1);
25408 _ssSetInputPortBufferDstPort(childS, 1, -1);
25409 _ssSetInputPortBufferDstPort(childS, 2, -1);
25410 }
25411
25412 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S165>/Generated S-Function1 (SaturationLimiter_sf) */
25413 {
25414 SimStruct *childS = ssGetSFunction(rts, 96);
25415
25416 /* timing info */
25417 time_T *sfcnPeriod;
25418 time_T *sfcnOffset;
25419 int_T *sfcnTsMap;
25420 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
25421 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
25422 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
25423 ss_VALIDATE_MEMORY(rts,sfcnOffset);
25424 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
25425 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
25426 (void) memset((void*)sfcnPeriod, 0,
25427 sizeof(time_T)*1);
25428 (void) memset((void*)sfcnOffset, 0,
25429 sizeof(time_T)*1);
25430 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
25431 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
25432 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
25433
25434 /* Set up the mdlInfo pointer */
25435# ifdef USE_RTMODEL
25436
25437 {
25438 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
25439 struct _ssBlkInfo2));
25440 ss_VALIDATE_MEMORY(rts,blkInfo2);
25441 ssSetBlkInfo2Ptr(childS, blkInfo2);
25442 }
25443
25444 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
25445
25446# else
25447
25448 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
25449
25450# endif /* USE_RTMODEL */
25451
25452 /* Allocate memory of model methods 2 */
25453 {
25454 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
25455 malloc(sizeof(struct _ssSFcnModelMethods2));
25456 ss_VALIDATE_MEMORY(rts,methods2);
25457 ssSetModelMethods2(childS, methods2);
25458 }
25459
25460 /* Allocate memory of model methods 3 */
25461 {
25462 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
25463 malloc(sizeof(struct _ssSFcnModelMethods3));
25464 ss_VALIDATE_MEMORY(rts,methods3);
25465 ssSetModelMethods3(childS, methods3);
25466 }
25467
25468 /* Allocate memory for states auxilliary information */
25469 {
25470 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
25471 (sizeof(struct _ssStatesInfo2));
25472 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
25473 malloc(sizeof(ssPeriodicStatesInfo));
25474 ss_VALIDATE_MEMORY(rts,statesInfo2);
25475 ssSetStatesInfo2(childS, statesInfo2);
25476 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
25477 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
25478 }
25479
25480 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
25481 RegNumInputPorts);
25482 ssSetRegNumInputPortsFcnArg(childS,childS);
25483
25484 /* inputs */
25485 {
25486 struct _ssPortInputs *inputPortInfo =
25487 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
25488 ss_VALIDATE_MEMORY(rts,inputPortInfo);
25489 _ssSetNumInputPorts(childS, 3);
25490 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
25491
25492 /* port 0 */
25493 {
25494 real32_T const **sfcnUPtrs = (real32_T const **)
25495 malloc(1 * sizeof(real32_T *));
25496 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25497 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
25498 ssGetLocalBlockIO(rts))->Divide1_d;
25499 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
25500 _ssSetInputPortNumDimensions(childS, 0, 1);
25501 ssSetInputPortWidth(childS, 0, 1);
25502 }
25503
25504 /* port 1 */
25505 {
25506 real32_T const **sfcnUPtrs = (real32_T const **)
25507 malloc(1 * sizeof(real32_T *));
25508 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25509 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
25510 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
25511 _ssSetInputPortNumDimensions(childS, 1, 1);
25512 ssSetInputPortWidth(childS, 1, 1);
25513 }
25514
25515 /* port 2 */
25516 {
25517 real32_T const **sfcnUPtrs = (real32_T const **)
25518 malloc(1 * sizeof(real32_T *));
25519 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25520 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled115;
25521 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
25522 _ssSetInputPortNumDimensions(childS, 2, 1);
25523 ssSetInputPortWidth(childS, 2, 1);
25524 }
25525 }
25526
25527 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
25528 RegNumOutputPorts);
25529 ssSetRegNumOutputPortsFcnArg(childS,childS);
25530
25531 /* outputs */
25532 {
25533 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
25534 calloc(1, sizeof(struct _ssPortOutputs));
25535 ss_VALIDATE_MEMORY(rts,outputPortInfo);
25536 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
25537 _ssSetNumOutputPorts(childS, 1);
25538
25539 /* port 0 */
25540 {
25541 _ssSetOutputPortNumDimensions(childS, 0, 1);
25542 ssSetOutputPortWidth(childS, 0, 1);
25543 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
25544 ssGetLocalBlockIO(rts))->GeneratedSFunction1_d));
25545 }
25546 }
25547
25548 /* path info */
25549 _ssSetModelName(childS, "SaturationLimiter_sf");
25550 _ssSetPath(childS,
25551 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/aprcLcontrol/RwyLControl/Saturation Limiter4/Generated S-Function1");
25552 if (ssGetRTModel(rts) == (NULL)) {
25553 _ssSetParentSS(childS, rts);
25554 _ssSetRootSS(childS, ssGetRootSS(rts));
25555 } else {
25556 ssSetRTModel(childS,ssGetRTModel(rts));
25557 _ssSetParentSS(childS, (NULL));
25558 _ssSetRootSS(childS, childS);
25559 }
25560
25561 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
25562 (childS)->regDataType.arg1 = ((void *)(childS));
25563 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
25564 FcnSetErrorStatus);
25565 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
25566 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
25567 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
25568 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
25569
25570 /* registration */
25571#if defined(MATLAB_MEX_FILE)
25572
25573 {
25574 int_T i;
25575 mxArray *plhs[1];
25576 mxArray *prhs[4];
25577 double *pr;
25578 volatile int_T *intS = (int_T *)&childS;
25579 int_T addrlen = sizeof(SimStruct *);
25580 int_T m = addrlen/sizeof(int_T) + 1;
25581 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
25582 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
25583 pr = mxGetPr(prhs[1]);
25584 for (i = 0; i < m - 1; i++) {
25585 pr[i] = (double)intS[i];
25586 }
25587
25588 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
25589 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
25590 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
25591
25592 /* Reset port dimensions info functions because the S-function
25593 * and accelerator mex-files explicitly set their dimensions,
25594 * i.e., they are not dynamically sized. For this case, the
25595 * mex-file is responsible for the dimensions info memory
25596 * and Simulink should not free it. This is achieved by
25597 * setting the following two methods to NULL.
25598 */
25599 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
25600 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
25601
25602 /*
25603 * Setup function pointers and call mdlInitializeSizes via
25604 * simulink.c
25605 */
25606 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
25607 mxDestroyArray(plhs[0]);
25608 mxDestroyArray(prhs[0]);
25609 mxDestroyArray(prhs[1]);
25610 mxDestroyArray(prhs[2]);
25611 mxDestroyArray(prhs[3]);
25612 }
25613
25614#else
25615
25616 {
25617 SaturationLimiter_sf(childS);
25618 sfcnInitializeSizes(childS);
25619 }
25620
25621#endif
25622
25623 sfcnInitializeSampleTimes(childS);
25624
25625 /* adjust sample time */
25626 ssSetSampleTime(childS, 0, 0.0);
25627 ssSetOffsetTime(childS, 0, 0.0);
25628 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
25629
25630 /* set compiled values of dynamic vector attributes */
25631 ssSetNumNonsampledZCs(childS, 0);
25632
25633 /* Update connectivity flags for each port */
25634 _ssSetInputPortConnected(childS, 0, 1);
25635 _ssSetInputPortConnected(childS, 1, 1);
25636 _ssSetInputPortConnected(childS, 2, 1);
25637 _ssSetOutputPortConnected(childS, 0, 1);
25638 _ssSetOutputPortBeingMerged(childS, 0, 0);
25639
25640 /* Update the BufferDstPort flags for each input port */
25641 _ssSetInputPortBufferDstPort(childS, 0, -1);
25642 _ssSetInputPortBufferDstPort(childS, 1, -1);
25643 _ssSetInputPortBufferDstPort(childS, 2, -1);
25644 }
25645
25646 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S190>/Generated S-Function4 (LagFilter_sf) */
25647 {
25648 SimStruct *childS = ssGetSFunction(rts, 97);
25649
25650 /* timing info */
25651 time_T *sfcnPeriod;
25652 time_T *sfcnOffset;
25653 int_T *sfcnTsMap;
25654 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
25655 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
25656 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
25657 ss_VALIDATE_MEMORY(rts,sfcnOffset);
25658 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
25659 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
25660 (void) memset((void*)sfcnPeriod, 0,
25661 sizeof(time_T)*1);
25662 (void) memset((void*)sfcnOffset, 0,
25663 sizeof(time_T)*1);
25664 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
25665 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
25666 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
25667
25668 /* Set up the mdlInfo pointer */
25669# ifdef USE_RTMODEL
25670
25671 {
25672 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
25673 struct _ssBlkInfo2));
25674 ss_VALIDATE_MEMORY(rts,blkInfo2);
25675 ssSetBlkInfo2Ptr(childS, blkInfo2);
25676 }
25677
25678 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
25679
25680# else
25681
25682 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
25683
25684# endif /* USE_RTMODEL */
25685
25686 /* Allocate memory of model methods 2 */
25687 {
25688 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
25689 malloc(sizeof(struct _ssSFcnModelMethods2));
25690 ss_VALIDATE_MEMORY(rts,methods2);
25691 ssSetModelMethods2(childS, methods2);
25692 }
25693
25694 /* Allocate memory of model methods 3 */
25695 {
25696 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
25697 malloc(sizeof(struct _ssSFcnModelMethods3));
25698 ss_VALIDATE_MEMORY(rts,methods3);
25699 ssSetModelMethods3(childS, methods3);
25700 }
25701
25702 /* Allocate memory for states auxilliary information */
25703 {
25704 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
25705 (sizeof(struct _ssStatesInfo2));
25706 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
25707 malloc(sizeof(ssPeriodicStatesInfo));
25708 ss_VALIDATE_MEMORY(rts,statesInfo2);
25709 ssSetStatesInfo2(childS, statesInfo2);
25710 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
25711 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
25712 }
25713
25714 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
25715 RegNumInputPorts);
25716 ssSetRegNumInputPortsFcnArg(childS,childS);
25717
25718 /* inputs */
25719 {
25720 struct _ssPortInputs *inputPortInfo =
25721 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
25722 ss_VALIDATE_MEMORY(rts,inputPortInfo);
25723 _ssSetNumInputPorts(childS, 6);
25724 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
25725
25726 /* port 0 */
25727 {
25728 real32_T const **sfcnUPtrs = (real32_T const **)
25729 malloc(1 * sizeof(real32_T *));
25730 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25731 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
25732 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
25733 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
25734 _ssSetInputPortNumDimensions(childS, 0, 1);
25735 ssSetInputPortWidth(childS, 0, 1);
25736 }
25737
25738 /* port 1 */
25739 {
25740 int8_T const **sfcnUPtrs = (int8_T const **)
25741 malloc(1 * sizeof(int8_T *));
25742 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25743 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
25744 ssGetLocalBlockIO(rts))->DataTypeConversion_f;
25745 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
25746 _ssSetInputPortNumDimensions(childS, 1, 1);
25747 ssSetInputPortWidth(childS, 1, 1);
25748 }
25749
25750 /* port 2 */
25751 {
25752 real32_T const **sfcnUPtrs = (real32_T const **)
25753 malloc(1 * sizeof(real32_T *));
25754 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25755 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled124;
25756 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
25757 _ssSetInputPortNumDimensions(childS, 2, 1);
25758 ssSetInputPortWidth(childS, 2, 1);
25759 }
25760
25761 /* port 3 */
25762 {
25763 real32_T const **sfcnUPtrs = (real32_T const **)
25764 malloc(1 * sizeof(real32_T *));
25765 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25766 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
25767 ssGetLocalBlockIO(rts))->Switch_jf;
25768 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
25769 _ssSetInputPortNumDimensions(childS, 3, 1);
25770 ssSetInputPortWidth(childS, 3, 1);
25771 }
25772
25773 /* port 4 */
25774 {
25775 real32_T const **sfcnUPtrs = (real32_T const **)
25776 malloc(1 * sizeof(real32_T *));
25777 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25778 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
25779 ssGetLocalBlockIO(rts))->Switch_jf;
25780 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
25781 _ssSetInputPortNumDimensions(childS, 4, 1);
25782 ssSetInputPortWidth(childS, 4, 1);
25783 }
25784
25785 /* port 5 */
25786 {
25787 real32_T const **sfcnUPtrs = (real32_T const **)
25788 malloc(1 * sizeof(real32_T *));
25789 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
25790 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
25791 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
25792 _ssSetInputPortNumDimensions(childS, 5, 1);
25793 ssSetInputPortWidth(childS, 5, 1);
25794 }
25795 }
25796
25797 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
25798 RegNumOutputPorts);
25799 ssSetRegNumOutputPortsFcnArg(childS,childS);
25800
25801 /* outputs */
25802 {
25803 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
25804 calloc(1, sizeof(struct _ssPortOutputs));
25805 ss_VALIDATE_MEMORY(rts,outputPortInfo);
25806 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
25807 _ssSetNumOutputPorts(childS, 1);
25808
25809 /* port 0 */
25810 {
25811 _ssSetOutputPortNumDimensions(childS, 0, 1);
25812 ssSetOutputPortWidth(childS, 0, 1);
25813 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
25814 ssGetLocalBlockIO(rts))->GeneratedSFunction4_k));
25815 }
25816 }
25817
25818 /* path info */
25819 _ssSetModelName(childS, "LagFilter_sf");
25820 _ssSetPath(childS,
25821 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/ lag filter/Generated S-Function4");
25822 if (ssGetRTModel(rts) == (NULL)) {
25823 _ssSetParentSS(childS, rts);
25824 _ssSetRootSS(childS, ssGetRootSS(rts));
25825 } else {
25826 ssSetRTModel(childS,ssGetRTModel(rts));
25827 _ssSetParentSS(childS, (NULL));
25828 _ssSetRootSS(childS, childS);
25829 }
25830
25831 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
25832
25833 /* work vectors */
25834 {
25835 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
25836 (4 * sizeof(struct _ssDWorkRecord));
25837 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
25838 calloc(4, sizeof(struct _ssDWorkAuxRecord));
25839 ss_VALIDATE_MEMORY(rts,dWorkRecord);
25840 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
25841 ssSetSFcnDWork(childS, dWorkRecord);
25842 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
25843 _ssSetNumDWork(childS, 4);
25844
25845 /* DWORK0 */
25846 ssSetDWorkWidth(childS, 0, 1);
25847 ssSetDWorkDataType(childS, 0,SS_SINGLE);
25848 ssSetDWorkComplexSignal(childS, 0, 0);
25849 ssSetDWorkUsedAsDState(childS, 0, 1);
25850 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 219))[0]);
25851
25852 /* DWORK1 */
25853 ssSetDWorkWidth(childS, 1, 1);
25854 ssSetDWorkDataType(childS, 1,SS_SINGLE);
25855 ssSetDWorkComplexSignal(childS, 1, 0);
25856 ssSetDWorkUsedAsDState(childS, 1, 1);
25857 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 220))[0]);
25858
25859 /* DWORK2 */
25860 ssSetDWorkWidth(childS, 2, 1);
25861 ssSetDWorkDataType(childS, 2,SS_INT8);
25862 ssSetDWorkComplexSignal(childS, 2, 0);
25863 ssSetDWorkUsedAsDState(childS, 2, 1);
25864 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 446))[0]);
25865
25866 /* DWORK3 */
25867 ssSetDWorkWidth(childS, 3, 1);
25868 ssSetDWorkDataType(childS, 3,SS_INT8);
25869 ssSetDWorkComplexSignal(childS, 3, 0);
25870 ssSetDWorkUsedAsDState(childS, 3, 1);
25871 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 447))[0]);
25872 }
25873
25874 (childS)->regDataType.arg1 = ((void *)(childS));
25875 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
25876 FcnSetErrorStatus);
25877 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
25878 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
25879 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
25880 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
25881
25882 /* registration */
25883#if defined(MATLAB_MEX_FILE)
25884
25885 {
25886 int_T i;
25887 mxArray *plhs[1];
25888 mxArray *prhs[4];
25889 double *pr;
25890 volatile int_T *intS = (int_T *)&childS;
25891 int_T addrlen = sizeof(SimStruct *);
25892 int_T m = addrlen/sizeof(int_T) + 1;
25893 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
25894 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
25895 pr = mxGetPr(prhs[1]);
25896 for (i = 0; i < m - 1; i++) {
25897 pr[i] = (double)intS[i];
25898 }
25899
25900 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
25901 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
25902 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
25903
25904 /* Reset port dimensions info functions because the S-function
25905 * and accelerator mex-files explicitly set their dimensions,
25906 * i.e., they are not dynamically sized. For this case, the
25907 * mex-file is responsible for the dimensions info memory
25908 * and Simulink should not free it. This is achieved by
25909 * setting the following two methods to NULL.
25910 */
25911 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
25912 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
25913
25914 /*
25915 * Setup function pointers and call mdlInitializeSizes via
25916 * simulink.c
25917 */
25918 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
25919 mxDestroyArray(plhs[0]);
25920 mxDestroyArray(prhs[0]);
25921 mxDestroyArray(prhs[1]);
25922 mxDestroyArray(prhs[2]);
25923 mxDestroyArray(prhs[3]);
25924 }
25925
25926#else
25927
25928 {
25929 LagFilter_sf(childS);
25930 sfcnInitializeSizes(childS);
25931 }
25932
25933#endif
25934
25935 sfcnInitializeSampleTimes(childS);
25936
25937 /* adjust sample time */
25938 ssSetSampleTime(childS, 0, 0.0);
25939 ssSetOffsetTime(childS, 0, 0.0);
25940 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
25941
25942 /* set compiled values of dynamic vector attributes */
25943 ssSetNumNonsampledZCs(childS, 0);
25944
25945 /* Update connectivity flags for each port */
25946 _ssSetInputPortConnected(childS, 0, 1);
25947 _ssSetInputPortConnected(childS, 1, 1);
25948 _ssSetInputPortConnected(childS, 2, 1);
25949 _ssSetInputPortConnected(childS, 3, 1);
25950 _ssSetInputPortConnected(childS, 4, 1);
25951 _ssSetInputPortConnected(childS, 5, 1);
25952 _ssSetOutputPortConnected(childS, 0, 1);
25953 _ssSetOutputPortBeingMerged(childS, 0, 0);
25954
25955 /* Update the BufferDstPort flags for each input port */
25956 _ssSetInputPortBufferDstPort(childS, 0, -1);
25957 _ssSetInputPortBufferDstPort(childS, 1, -1);
25958 _ssSetInputPortBufferDstPort(childS, 2, -1);
25959 _ssSetInputPortBufferDstPort(childS, 3, -1);
25960 _ssSetInputPortBufferDstPort(childS, 4, -1);
25961 _ssSetInputPortBufferDstPort(childS, 5, -1);
25962 }
25963
25964 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S191>/Generated S-Function4 (LagFilter_sf) */
25965 {
25966 SimStruct *childS = ssGetSFunction(rts, 98);
25967
25968 /* timing info */
25969 time_T *sfcnPeriod;
25970 time_T *sfcnOffset;
25971 int_T *sfcnTsMap;
25972 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
25973 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
25974 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
25975 ss_VALIDATE_MEMORY(rts,sfcnOffset);
25976 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
25977 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
25978 (void) memset((void*)sfcnPeriod, 0,
25979 sizeof(time_T)*1);
25980 (void) memset((void*)sfcnOffset, 0,
25981 sizeof(time_T)*1);
25982 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
25983 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
25984 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
25985
25986 /* Set up the mdlInfo pointer */
25987# ifdef USE_RTMODEL
25988
25989 {
25990 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
25991 struct _ssBlkInfo2));
25992 ss_VALIDATE_MEMORY(rts,blkInfo2);
25993 ssSetBlkInfo2Ptr(childS, blkInfo2);
25994 }
25995
25996 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
25997
25998# else
25999
26000 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
26001
26002# endif /* USE_RTMODEL */
26003
26004 /* Allocate memory of model methods 2 */
26005 {
26006 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
26007 malloc(sizeof(struct _ssSFcnModelMethods2));
26008 ss_VALIDATE_MEMORY(rts,methods2);
26009 ssSetModelMethods2(childS, methods2);
26010 }
26011
26012 /* Allocate memory of model methods 3 */
26013 {
26014 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
26015 malloc(sizeof(struct _ssSFcnModelMethods3));
26016 ss_VALIDATE_MEMORY(rts,methods3);
26017 ssSetModelMethods3(childS, methods3);
26018 }
26019
26020 /* Allocate memory for states auxilliary information */
26021 {
26022 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
26023 (sizeof(struct _ssStatesInfo2));
26024 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
26025 malloc(sizeof(ssPeriodicStatesInfo));
26026 ss_VALIDATE_MEMORY(rts,statesInfo2);
26027 ssSetStatesInfo2(childS, statesInfo2);
26028 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
26029 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
26030 }
26031
26032 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
26033 RegNumInputPorts);
26034 ssSetRegNumInputPortsFcnArg(childS,childS);
26035
26036 /* inputs */
26037 {
26038 struct _ssPortInputs *inputPortInfo =
26039 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
26040 ss_VALIDATE_MEMORY(rts,inputPortInfo);
26041 _ssSetNumInputPorts(childS, 6);
26042 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
26043
26044 /* port 0 */
26045 {
26046 real32_T const **sfcnUPtrs = (real32_T const **)
26047 malloc(1 * sizeof(real32_T *));
26048 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26049 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
26050 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
26051 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
26052 _ssSetInputPortNumDimensions(childS, 0, 1);
26053 ssSetInputPortWidth(childS, 0, 1);
26054 }
26055
26056 /* port 1 */
26057 {
26058 int8_T const **sfcnUPtrs = (int8_T const **)
26059 malloc(1 * sizeof(int8_T *));
26060 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26061 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
26062 ssGetLocalBlockIO(rts))->DataTypeConversion3_l;
26063 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
26064 _ssSetInputPortNumDimensions(childS, 1, 1);
26065 ssSetInputPortWidth(childS, 1, 1);
26066 }
26067
26068 /* port 2 */
26069 {
26070 real32_T const **sfcnUPtrs = (real32_T const **)
26071 malloc(1 * sizeof(real32_T *));
26072 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26073 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled124;
26074 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
26075 _ssSetInputPortNumDimensions(childS, 2, 1);
26076 ssSetInputPortWidth(childS, 2, 1);
26077 }
26078
26079 /* port 3 */
26080 {
26081 real32_T const **sfcnUPtrs = (real32_T const **)
26082 malloc(1 * sizeof(real32_T *));
26083 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26084 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
26085 ssGetLocalBlockIO(rts))->Switch_jf;
26086 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
26087 _ssSetInputPortNumDimensions(childS, 3, 1);
26088 ssSetInputPortWidth(childS, 3, 1);
26089 }
26090
26091 /* port 4 */
26092 {
26093 real32_T const **sfcnUPtrs = (real32_T const **)
26094 malloc(1 * sizeof(real32_T *));
26095 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26096 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
26097 ssGetLocalBlockIO(rts))->Switch_jf;
26098 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
26099 _ssSetInputPortNumDimensions(childS, 4, 1);
26100 ssSetInputPortWidth(childS, 4, 1);
26101 }
26102
26103 /* port 5 */
26104 {
26105 real32_T const **sfcnUPtrs = (real32_T const **)
26106 malloc(1 * sizeof(real32_T *));
26107 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26108 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
26109 ssGetLocalBlockIO(rts))->Switch7;
26110 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
26111 _ssSetInputPortNumDimensions(childS, 5, 1);
26112 ssSetInputPortWidth(childS, 5, 1);
26113 }
26114 }
26115
26116 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
26117 RegNumOutputPorts);
26118 ssSetRegNumOutputPortsFcnArg(childS,childS);
26119
26120 /* outputs */
26121 {
26122 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
26123 calloc(1, sizeof(struct _ssPortOutputs));
26124 ss_VALIDATE_MEMORY(rts,outputPortInfo);
26125 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
26126 _ssSetNumOutputPorts(childS, 1);
26127
26128 /* port 0 */
26129 {
26130 _ssSetOutputPortNumDimensions(childS, 0, 1);
26131 ssSetOutputPortWidth(childS, 0, 1);
26132 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
26133 ssGetLocalBlockIO(rts))->GeneratedSFunction4_p));
26134 }
26135 }
26136
26137 /* path info */
26138 _ssSetModelName(childS, "LagFilter_sf");
26139 _ssSetPath(childS,
26140 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/ lag filter1/Generated S-Function4");
26141 if (ssGetRTModel(rts) == (NULL)) {
26142 _ssSetParentSS(childS, rts);
26143 _ssSetRootSS(childS, ssGetRootSS(rts));
26144 } else {
26145 ssSetRTModel(childS,ssGetRTModel(rts));
26146 _ssSetParentSS(childS, (NULL));
26147 _ssSetRootSS(childS, childS);
26148 }
26149
26150 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
26151
26152 /* work vectors */
26153 {
26154 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
26155 (4 * sizeof(struct _ssDWorkRecord));
26156 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
26157 calloc(4, sizeof(struct _ssDWorkAuxRecord));
26158 ss_VALIDATE_MEMORY(rts,dWorkRecord);
26159 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
26160 ssSetSFcnDWork(childS, dWorkRecord);
26161 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
26162 _ssSetNumDWork(childS, 4);
26163
26164 /* DWORK0 */
26165 ssSetDWorkWidth(childS, 0, 1);
26166 ssSetDWorkDataType(childS, 0,SS_SINGLE);
26167 ssSetDWorkComplexSignal(childS, 0, 0);
26168 ssSetDWorkUsedAsDState(childS, 0, 1);
26169 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 221))[0]);
26170
26171 /* DWORK1 */
26172 ssSetDWorkWidth(childS, 1, 1);
26173 ssSetDWorkDataType(childS, 1,SS_SINGLE);
26174 ssSetDWorkComplexSignal(childS, 1, 0);
26175 ssSetDWorkUsedAsDState(childS, 1, 1);
26176 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 222))[0]);
26177
26178 /* DWORK2 */
26179 ssSetDWorkWidth(childS, 2, 1);
26180 ssSetDWorkDataType(childS, 2,SS_INT8);
26181 ssSetDWorkComplexSignal(childS, 2, 0);
26182 ssSetDWorkUsedAsDState(childS, 2, 1);
26183 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 448))[0]);
26184
26185 /* DWORK3 */
26186 ssSetDWorkWidth(childS, 3, 1);
26187 ssSetDWorkDataType(childS, 3,SS_INT8);
26188 ssSetDWorkComplexSignal(childS, 3, 0);
26189 ssSetDWorkUsedAsDState(childS, 3, 1);
26190 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 449))[0]);
26191 }
26192
26193 (childS)->regDataType.arg1 = ((void *)(childS));
26194 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
26195 FcnSetErrorStatus);
26196 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
26197 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
26198 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
26199 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
26200
26201 /* registration */
26202#if defined(MATLAB_MEX_FILE)
26203
26204 {
26205 int_T i;
26206 mxArray *plhs[1];
26207 mxArray *prhs[4];
26208 double *pr;
26209 volatile int_T *intS = (int_T *)&childS;
26210 int_T addrlen = sizeof(SimStruct *);
26211 int_T m = addrlen/sizeof(int_T) + 1;
26212 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
26213 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
26214 pr = mxGetPr(prhs[1]);
26215 for (i = 0; i < m - 1; i++) {
26216 pr[i] = (double)intS[i];
26217 }
26218
26219 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
26220 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
26221 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
26222
26223 /* Reset port dimensions info functions because the S-function
26224 * and accelerator mex-files explicitly set their dimensions,
26225 * i.e., they are not dynamically sized. For this case, the
26226 * mex-file is responsible for the dimensions info memory
26227 * and Simulink should not free it. This is achieved by
26228 * setting the following two methods to NULL.
26229 */
26230 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
26231 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
26232
26233 /*
26234 * Setup function pointers and call mdlInitializeSizes via
26235 * simulink.c
26236 */
26237 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
26238 mxDestroyArray(plhs[0]);
26239 mxDestroyArray(prhs[0]);
26240 mxDestroyArray(prhs[1]);
26241 mxDestroyArray(prhs[2]);
26242 mxDestroyArray(prhs[3]);
26243 }
26244
26245#else
26246
26247 {
26248 LagFilter_sf(childS);
26249 sfcnInitializeSizes(childS);
26250 }
26251
26252#endif
26253
26254 sfcnInitializeSampleTimes(childS);
26255
26256 /* adjust sample time */
26257 ssSetSampleTime(childS, 0, 0.0);
26258 ssSetOffsetTime(childS, 0, 0.0);
26259 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
26260
26261 /* set compiled values of dynamic vector attributes */
26262 ssSetNumNonsampledZCs(childS, 0);
26263
26264 /* Update connectivity flags for each port */
26265 _ssSetInputPortConnected(childS, 0, 1);
26266 _ssSetInputPortConnected(childS, 1, 1);
26267 _ssSetInputPortConnected(childS, 2, 1);
26268 _ssSetInputPortConnected(childS, 3, 1);
26269 _ssSetInputPortConnected(childS, 4, 1);
26270 _ssSetInputPortConnected(childS, 5, 1);
26271 _ssSetOutputPortConnected(childS, 0, 1);
26272 _ssSetOutputPortBeingMerged(childS, 0, 0);
26273
26274 /* Update the BufferDstPort flags for each input port */
26275 _ssSetInputPortBufferDstPort(childS, 0, -1);
26276 _ssSetInputPortBufferDstPort(childS, 1, -1);
26277 _ssSetInputPortBufferDstPort(childS, 2, -1);
26278 _ssSetInputPortBufferDstPort(childS, 3, -1);
26279 _ssSetInputPortBufferDstPort(childS, 4, -1);
26280 _ssSetInputPortBufferDstPort(childS, 5, -1);
26281 }
26282
26283 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S193>/Generated S-Function (Res180_sf) */
26284 {
26285 SimStruct *childS = ssGetSFunction(rts, 99);
26286
26287 /* timing info */
26288 time_T *sfcnPeriod;
26289 time_T *sfcnOffset;
26290 int_T *sfcnTsMap;
26291 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
26292 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
26293 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
26294 ss_VALIDATE_MEMORY(rts,sfcnOffset);
26295 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
26296 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
26297 (void) memset((void*)sfcnPeriod, 0,
26298 sizeof(time_T)*1);
26299 (void) memset((void*)sfcnOffset, 0,
26300 sizeof(time_T)*1);
26301 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
26302 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
26303 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
26304
26305 /* Set up the mdlInfo pointer */
26306# ifdef USE_RTMODEL
26307
26308 {
26309 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
26310 struct _ssBlkInfo2));
26311 ss_VALIDATE_MEMORY(rts,blkInfo2);
26312 ssSetBlkInfo2Ptr(childS, blkInfo2);
26313 }
26314
26315 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
26316
26317# else
26318
26319 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
26320
26321# endif /* USE_RTMODEL */
26322
26323 /* Allocate memory of model methods 2 */
26324 {
26325 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
26326 malloc(sizeof(struct _ssSFcnModelMethods2));
26327 ss_VALIDATE_MEMORY(rts,methods2);
26328 ssSetModelMethods2(childS, methods2);
26329 }
26330
26331 /* Allocate memory of model methods 3 */
26332 {
26333 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
26334 malloc(sizeof(struct _ssSFcnModelMethods3));
26335 ss_VALIDATE_MEMORY(rts,methods3);
26336 ssSetModelMethods3(childS, methods3);
26337 }
26338
26339 /* Allocate memory for states auxilliary information */
26340 {
26341 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
26342 (sizeof(struct _ssStatesInfo2));
26343 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
26344 malloc(sizeof(ssPeriodicStatesInfo));
26345 ss_VALIDATE_MEMORY(rts,statesInfo2);
26346 ssSetStatesInfo2(childS, statesInfo2);
26347 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
26348 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
26349 }
26350
26351 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
26352 RegNumInputPorts);
26353 ssSetRegNumInputPortsFcnArg(childS,childS);
26354
26355 /* inputs */
26356 {
26357 struct _ssPortInputs *inputPortInfo =
26358 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
26359 ss_VALIDATE_MEMORY(rts,inputPortInfo);
26360 _ssSetNumInputPorts(childS, 1);
26361 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
26362
26363 /* port 0 */
26364 {
26365 real32_T const **sfcnUPtrs = (real32_T const **)
26366 malloc(1 * sizeof(real32_T *));
26367 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26368 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
26369 ssGetLocalBlockIO(rts))->Sum3_g5;
26370 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
26371 _ssSetInputPortNumDimensions(childS, 0, 1);
26372 ssSetInputPortWidth(childS, 0, 1);
26373 }
26374 }
26375
26376 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
26377 RegNumOutputPorts);
26378 ssSetRegNumOutputPortsFcnArg(childS,childS);
26379
26380 /* outputs */
26381 {
26382 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
26383 calloc(1, sizeof(struct _ssPortOutputs));
26384 ss_VALIDATE_MEMORY(rts,outputPortInfo);
26385 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
26386 _ssSetNumOutputPorts(childS, 1);
26387
26388 /* port 0 */
26389 {
26390 _ssSetOutputPortNumDimensions(childS, 0, 1);
26391 ssSetOutputPortWidth(childS, 0, 1);
26392 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
26393 ssGetLocalBlockIO(rts))->GeneratedSFunction_bb));
26394 }
26395 }
26396
26397 /* path info */
26398 _ssSetModelName(childS, "Res180_sf");
26399 _ssSetPath(childS,
26400 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/Generated S-Function");
26401 if (ssGetRTModel(rts) == (NULL)) {
26402 _ssSetParentSS(childS, rts);
26403 _ssSetRootSS(childS, ssGetRootSS(rts));
26404 } else {
26405 ssSetRTModel(childS,ssGetRTModel(rts));
26406 _ssSetParentSS(childS, (NULL));
26407 _ssSetRootSS(childS, childS);
26408 }
26409
26410 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
26411 (childS)->regDataType.arg1 = ((void *)(childS));
26412 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
26413 FcnSetErrorStatus);
26414 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
26415 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
26416 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
26417 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
26418
26419 /* registration */
26420#if defined(MATLAB_MEX_FILE)
26421
26422 {
26423 int_T i;
26424 mxArray *plhs[1];
26425 mxArray *prhs[4];
26426 double *pr;
26427 volatile int_T *intS = (int_T *)&childS;
26428 int_T addrlen = sizeof(SimStruct *);
26429 int_T m = addrlen/sizeof(int_T) + 1;
26430 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
26431 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
26432 pr = mxGetPr(prhs[1]);
26433 for (i = 0; i < m - 1; i++) {
26434 pr[i] = (double)intS[i];
26435 }
26436
26437 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
26438 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
26439 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
26440
26441 /* Reset port dimensions info functions because the S-function
26442 * and accelerator mex-files explicitly set their dimensions,
26443 * i.e., they are not dynamically sized. For this case, the
26444 * mex-file is responsible for the dimensions info memory
26445 * and Simulink should not free it. This is achieved by
26446 * setting the following two methods to NULL.
26447 */
26448 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
26449 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
26450
26451 /*
26452 * Setup function pointers and call mdlInitializeSizes via
26453 * simulink.c
26454 */
26455 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
26456 mxDestroyArray(plhs[0]);
26457 mxDestroyArray(prhs[0]);
26458 mxDestroyArray(prhs[1]);
26459 mxDestroyArray(prhs[2]);
26460 mxDestroyArray(prhs[3]);
26461 }
26462
26463#else
26464
26465 {
26466 Res180_sf(childS);
26467 sfcnInitializeSizes(childS);
26468 }
26469
26470#endif
26471
26472 sfcnInitializeSampleTimes(childS);
26473
26474 /* adjust sample time */
26475 ssSetSampleTime(childS, 0, 0.0);
26476 ssSetOffsetTime(childS, 0, 0.0);
26477 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
26478
26479 /* set compiled values of dynamic vector attributes */
26480 ssSetNumNonsampledZCs(childS, 0);
26481
26482 /* Update connectivity flags for each port */
26483 _ssSetInputPortConnected(childS, 0, 1);
26484 _ssSetOutputPortConnected(childS, 0, 1);
26485 _ssSetOutputPortBeingMerged(childS, 0, 0);
26486
26487 /* Update the BufferDstPort flags for each input port */
26488 _ssSetInputPortBufferDstPort(childS, 0, -1);
26489 }
26490
26491 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S198>/Generated S-Function1 (SaturationLimiter_sf) */
26492 {
26493 SimStruct *childS = ssGetSFunction(rts, 100);
26494
26495 /* timing info */
26496 time_T *sfcnPeriod;
26497 time_T *sfcnOffset;
26498 int_T *sfcnTsMap;
26499 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
26500 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
26501 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
26502 ss_VALIDATE_MEMORY(rts,sfcnOffset);
26503 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
26504 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
26505 (void) memset((void*)sfcnPeriod, 0,
26506 sizeof(time_T)*1);
26507 (void) memset((void*)sfcnOffset, 0,
26508 sizeof(time_T)*1);
26509 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
26510 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
26511 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
26512
26513 /* Set up the mdlInfo pointer */
26514# ifdef USE_RTMODEL
26515
26516 {
26517 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
26518 struct _ssBlkInfo2));
26519 ss_VALIDATE_MEMORY(rts,blkInfo2);
26520 ssSetBlkInfo2Ptr(childS, blkInfo2);
26521 }
26522
26523 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
26524
26525# else
26526
26527 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
26528
26529# endif /* USE_RTMODEL */
26530
26531 /* Allocate memory of model methods 2 */
26532 {
26533 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
26534 malloc(sizeof(struct _ssSFcnModelMethods2));
26535 ss_VALIDATE_MEMORY(rts,methods2);
26536 ssSetModelMethods2(childS, methods2);
26537 }
26538
26539 /* Allocate memory of model methods 3 */
26540 {
26541 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
26542 malloc(sizeof(struct _ssSFcnModelMethods3));
26543 ss_VALIDATE_MEMORY(rts,methods3);
26544 ssSetModelMethods3(childS, methods3);
26545 }
26546
26547 /* Allocate memory for states auxilliary information */
26548 {
26549 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
26550 (sizeof(struct _ssStatesInfo2));
26551 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
26552 malloc(sizeof(ssPeriodicStatesInfo));
26553 ss_VALIDATE_MEMORY(rts,statesInfo2);
26554 ssSetStatesInfo2(childS, statesInfo2);
26555 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
26556 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
26557 }
26558
26559 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
26560 RegNumInputPorts);
26561 ssSetRegNumInputPortsFcnArg(childS,childS);
26562
26563 /* inputs */
26564 {
26565 struct _ssPortInputs *inputPortInfo =
26566 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
26567 ss_VALIDATE_MEMORY(rts,inputPortInfo);
26568 _ssSetNumInputPorts(childS, 3);
26569 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
26570
26571 /* port 0 */
26572 {
26573 real32_T const **sfcnUPtrs = (real32_T const **)
26574 malloc(1 * sizeof(real32_T *));
26575 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26576 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
26577 ssGetLocalBlockIO(rts))->GeneratedSFunction_bb;
26578 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
26579 _ssSetInputPortNumDimensions(childS, 0, 1);
26580 ssSetInputPortWidth(childS, 0, 1);
26581 }
26582
26583 /* port 1 */
26584 {
26585 real32_T const **sfcnUPtrs = (real32_T const **)
26586 malloc(1 * sizeof(real32_T *));
26587 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26588 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;
26589 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
26590 _ssSetInputPortNumDimensions(childS, 1, 1);
26591 ssSetInputPortWidth(childS, 1, 1);
26592 }
26593
26594 /* port 2 */
26595 {
26596 real32_T const **sfcnUPtrs = (real32_T const **)
26597 malloc(1 * sizeof(real32_T *));
26598 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26599 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;
26600 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
26601 _ssSetInputPortNumDimensions(childS, 2, 1);
26602 ssSetInputPortWidth(childS, 2, 1);
26603 }
26604 }
26605
26606 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
26607 RegNumOutputPorts);
26608 ssSetRegNumOutputPortsFcnArg(childS,childS);
26609
26610 /* outputs */
26611 {
26612 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
26613 calloc(1, sizeof(struct _ssPortOutputs));
26614 ss_VALIDATE_MEMORY(rts,outputPortInfo);
26615 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
26616 _ssSetNumOutputPorts(childS, 1);
26617
26618 /* port 0 */
26619 {
26620 _ssSetOutputPortNumDimensions(childS, 0, 1);
26621 ssSetOutputPortWidth(childS, 0, 1);
26622 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
26623 ssGetLocalBlockIO(rts))->GeneratedSFunction1_mq));
26624 }
26625 }
26626
26627 /* path info */
26628 _ssSetModelName(childS, "SaturationLimiter_sf");
26629 _ssSetPath(childS,
26630 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/Saturation Limiter1/Generated S-Function1");
26631 if (ssGetRTModel(rts) == (NULL)) {
26632 _ssSetParentSS(childS, rts);
26633 _ssSetRootSS(childS, ssGetRootSS(rts));
26634 } else {
26635 ssSetRTModel(childS,ssGetRTModel(rts));
26636 _ssSetParentSS(childS, (NULL));
26637 _ssSetRootSS(childS, childS);
26638 }
26639
26640 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
26641 (childS)->regDataType.arg1 = ((void *)(childS));
26642 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
26643 FcnSetErrorStatus);
26644 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
26645 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
26646 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
26647 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
26648
26649 /* registration */
26650#if defined(MATLAB_MEX_FILE)
26651
26652 {
26653 int_T i;
26654 mxArray *plhs[1];
26655 mxArray *prhs[4];
26656 double *pr;
26657 volatile int_T *intS = (int_T *)&childS;
26658 int_T addrlen = sizeof(SimStruct *);
26659 int_T m = addrlen/sizeof(int_T) + 1;
26660 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
26661 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
26662 pr = mxGetPr(prhs[1]);
26663 for (i = 0; i < m - 1; i++) {
26664 pr[i] = (double)intS[i];
26665 }
26666
26667 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
26668 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
26669 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
26670
26671 /* Reset port dimensions info functions because the S-function
26672 * and accelerator mex-files explicitly set their dimensions,
26673 * i.e., they are not dynamically sized. For this case, the
26674 * mex-file is responsible for the dimensions info memory
26675 * and Simulink should not free it. This is achieved by
26676 * setting the following two methods to NULL.
26677 */
26678 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
26679 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
26680
26681 /*
26682 * Setup function pointers and call mdlInitializeSizes via
26683 * simulink.c
26684 */
26685 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
26686 mxDestroyArray(plhs[0]);
26687 mxDestroyArray(prhs[0]);
26688 mxDestroyArray(prhs[1]);
26689 mxDestroyArray(prhs[2]);
26690 mxDestroyArray(prhs[3]);
26691 }
26692
26693#else
26694
26695 {
26696 SaturationLimiter_sf(childS);
26697 sfcnInitializeSizes(childS);
26698 }
26699
26700#endif
26701
26702 sfcnInitializeSampleTimes(childS);
26703
26704 /* adjust sample time */
26705 ssSetSampleTime(childS, 0, 0.0);
26706 ssSetOffsetTime(childS, 0, 0.0);
26707 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
26708
26709 /* set compiled values of dynamic vector attributes */
26710 ssSetNumNonsampledZCs(childS, 0);
26711
26712 /* Update connectivity flags for each port */
26713 _ssSetInputPortConnected(childS, 0, 1);
26714 _ssSetInputPortConnected(childS, 1, 1);
26715 _ssSetInputPortConnected(childS, 2, 1);
26716 _ssSetOutputPortConnected(childS, 0, 1);
26717 _ssSetOutputPortBeingMerged(childS, 0, 0);
26718
26719 /* Update the BufferDstPort flags for each input port */
26720 _ssSetInputPortBufferDstPort(childS, 0, -1);
26721 _ssSetInputPortBufferDstPort(childS, 1, -1);
26722 _ssSetInputPortBufferDstPort(childS, 2, -1);
26723 }
26724
26725 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S199>/Generated S-Function (Gain_sf) */
26726 {
26727 SimStruct *childS = ssGetSFunction(rts, 101);
26728
26729 /* timing info */
26730 time_T *sfcnPeriod;
26731 time_T *sfcnOffset;
26732 int_T *sfcnTsMap;
26733 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
26734 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
26735 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
26736 ss_VALIDATE_MEMORY(rts,sfcnOffset);
26737 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
26738 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
26739 (void) memset((void*)sfcnPeriod, 0,
26740 sizeof(time_T)*1);
26741 (void) memset((void*)sfcnOffset, 0,
26742 sizeof(time_T)*1);
26743 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
26744 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
26745 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
26746
26747 /* Set up the mdlInfo pointer */
26748# ifdef USE_RTMODEL
26749
26750 {
26751 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
26752 struct _ssBlkInfo2));
26753 ss_VALIDATE_MEMORY(rts,blkInfo2);
26754 ssSetBlkInfo2Ptr(childS, blkInfo2);
26755 }
26756
26757 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
26758
26759# else
26760
26761 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
26762
26763# endif /* USE_RTMODEL */
26764
26765 /* Allocate memory of model methods 2 */
26766 {
26767 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
26768 malloc(sizeof(struct _ssSFcnModelMethods2));
26769 ss_VALIDATE_MEMORY(rts,methods2);
26770 ssSetModelMethods2(childS, methods2);
26771 }
26772
26773 /* Allocate memory of model methods 3 */
26774 {
26775 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
26776 malloc(sizeof(struct _ssSFcnModelMethods3));
26777 ss_VALIDATE_MEMORY(rts,methods3);
26778 ssSetModelMethods3(childS, methods3);
26779 }
26780
26781 /* Allocate memory for states auxilliary information */
26782 {
26783 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
26784 (sizeof(struct _ssStatesInfo2));
26785 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
26786 malloc(sizeof(ssPeriodicStatesInfo));
26787 ss_VALIDATE_MEMORY(rts,statesInfo2);
26788 ssSetStatesInfo2(childS, statesInfo2);
26789 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
26790 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
26791 }
26792
26793 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
26794 RegNumInputPorts);
26795 ssSetRegNumInputPortsFcnArg(childS,childS);
26796
26797 /* inputs */
26798 {
26799 struct _ssPortInputs *inputPortInfo =
26800 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
26801 ss_VALIDATE_MEMORY(rts,inputPortInfo);
26802 _ssSetNumInputPorts(childS, 2);
26803 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
26804
26805 /* port 0 */
26806 {
26807 real32_T const **sfcnUPtrs = (real32_T const **)
26808 malloc(1 * sizeof(real32_T *));
26809 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26810 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
26811 ssGetLocalBlockIO(rts))->GeneratedSFunction1_mq;
26812 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
26813 _ssSetInputPortNumDimensions(childS, 0, 1);
26814 ssSetInputPortWidth(childS, 0, 1);
26815 }
26816
26817 /* port 1 */
26818 {
26819 real32_T const **sfcnUPtrs = (real32_T const **)
26820 malloc(1 * sizeof(real32_T *));
26821 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
26822 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled122;
26823 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
26824 _ssSetInputPortNumDimensions(childS, 1, 1);
26825 ssSetInputPortWidth(childS, 1, 1);
26826 }
26827 }
26828
26829 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
26830 RegNumOutputPorts);
26831 ssSetRegNumOutputPortsFcnArg(childS,childS);
26832
26833 /* outputs */
26834 {
26835 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
26836 calloc(1, sizeof(struct _ssPortOutputs));
26837 ss_VALIDATE_MEMORY(rts,outputPortInfo);
26838 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
26839 _ssSetNumOutputPorts(childS, 1);
26840
26841 /* port 0 */
26842 {
26843 _ssSetOutputPortNumDimensions(childS, 0, 1);
26844 ssSetOutputPortWidth(childS, 0, 1);
26845 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
26846 ssGetLocalBlockIO(rts))->GeneratedSFunction_k5));
26847 }
26848 }
26849
26850 /* path info */
26851 _ssSetModelName(childS, "Gain_sf");
26852 _ssSetPath(childS,
26853 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/gain2/Generated S-Function");
26854 if (ssGetRTModel(rts) == (NULL)) {
26855 _ssSetParentSS(childS, rts);
26856 _ssSetRootSS(childS, ssGetRootSS(rts));
26857 } else {
26858 ssSetRTModel(childS,ssGetRTModel(rts));
26859 _ssSetParentSS(childS, (NULL));
26860 _ssSetRootSS(childS, childS);
26861 }
26862
26863 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
26864 (childS)->regDataType.arg1 = ((void *)(childS));
26865 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
26866 FcnSetErrorStatus);
26867 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
26868 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
26869 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
26870 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
26871
26872 /* registration */
26873#if defined(MATLAB_MEX_FILE)
26874
26875 {
26876 int_T i;
26877 mxArray *plhs[1];
26878 mxArray *prhs[4];
26879 double *pr;
26880 volatile int_T *intS = (int_T *)&childS;
26881 int_T addrlen = sizeof(SimStruct *);
26882 int_T m = addrlen/sizeof(int_T) + 1;
26883 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
26884 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
26885 pr = mxGetPr(prhs[1]);
26886 for (i = 0; i < m - 1; i++) {
26887 pr[i] = (double)intS[i];
26888 }
26889
26890 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
26891 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
26892 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
26893
26894 /* Reset port dimensions info functions because the S-function
26895 * and accelerator mex-files explicitly set their dimensions,
26896 * i.e., they are not dynamically sized. For this case, the
26897 * mex-file is responsible for the dimensions info memory
26898 * and Simulink should not free it. This is achieved by
26899 * setting the following two methods to NULL.
26900 */
26901 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
26902 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
26903
26904 /*
26905 * Setup function pointers and call mdlInitializeSizes via
26906 * simulink.c
26907 */
26908 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
26909 mxDestroyArray(plhs[0]);
26910 mxDestroyArray(prhs[0]);
26911 mxDestroyArray(prhs[1]);
26912 mxDestroyArray(prhs[2]);
26913 mxDestroyArray(prhs[3]);
26914 }
26915
26916#else
26917
26918 {
26919 Gain_sf(childS);
26920 sfcnInitializeSizes(childS);
26921 }
26922
26923#endif
26924
26925 sfcnInitializeSampleTimes(childS);
26926
26927 /* adjust sample time */
26928 ssSetSampleTime(childS, 0, 0.0);
26929 ssSetOffsetTime(childS, 0, 0.0);
26930 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
26931
26932 /* set compiled values of dynamic vector attributes */
26933 ssSetNumNonsampledZCs(childS, 0);
26934
26935 /* Update connectivity flags for each port */
26936 _ssSetInputPortConnected(childS, 0, 1);
26937 _ssSetInputPortConnected(childS, 1, 1);
26938 _ssSetOutputPortConnected(childS, 0, 1);
26939 _ssSetOutputPortBeingMerged(childS, 0, 0);
26940
26941 /* Update the BufferDstPort flags for each input port */
26942 _ssSetInputPortBufferDstPort(childS, 0, -1);
26943 _ssSetInputPortBufferDstPort(childS, 1, -1);
26944 }
26945
26946 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S197>/Generated S-Function2 (LeadLagFilter_sf) */
26947 {
26948 SimStruct *childS = ssGetSFunction(rts, 102);
26949
26950 /* timing info */
26951 time_T *sfcnPeriod;
26952 time_T *sfcnOffset;
26953 int_T *sfcnTsMap;
26954 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
26955 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
26956 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
26957 ss_VALIDATE_MEMORY(rts,sfcnOffset);
26958 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
26959 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
26960 (void) memset((void*)sfcnPeriod, 0,
26961 sizeof(time_T)*1);
26962 (void) memset((void*)sfcnOffset, 0,
26963 sizeof(time_T)*1);
26964 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
26965 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
26966 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
26967
26968 /* Set up the mdlInfo pointer */
26969# ifdef USE_RTMODEL
26970
26971 {
26972 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
26973 struct _ssBlkInfo2));
26974 ss_VALIDATE_MEMORY(rts,blkInfo2);
26975 ssSetBlkInfo2Ptr(childS, blkInfo2);
26976 }
26977
26978 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
26979
26980# else
26981
26982 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
26983
26984# endif /* USE_RTMODEL */
26985
26986 /* Allocate memory of model methods 2 */
26987 {
26988 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
26989 malloc(sizeof(struct _ssSFcnModelMethods2));
26990 ss_VALIDATE_MEMORY(rts,methods2);
26991 ssSetModelMethods2(childS, methods2);
26992 }
26993
26994 /* Allocate memory of model methods 3 */
26995 {
26996 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
26997 malloc(sizeof(struct _ssSFcnModelMethods3));
26998 ss_VALIDATE_MEMORY(rts,methods3);
26999 ssSetModelMethods3(childS, methods3);
27000 }
27001
27002 /* Allocate memory for states auxilliary information */
27003 {
27004 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
27005 (sizeof(struct _ssStatesInfo2));
27006 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
27007 malloc(sizeof(ssPeriodicStatesInfo));
27008 ss_VALIDATE_MEMORY(rts,statesInfo2);
27009 ssSetStatesInfo2(childS, statesInfo2);
27010 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
27011 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
27012 }
27013
27014 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
27015 RegNumInputPorts);
27016 ssSetRegNumInputPortsFcnArg(childS,childS);
27017
27018 /* inputs */
27019 {
27020 struct _ssPortInputs *inputPortInfo =
27021 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
27022 ss_VALIDATE_MEMORY(rts,inputPortInfo);
27023 _ssSetNumInputPorts(childS, 7);
27024 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
27025
27026 /* port 0 */
27027 {
27028 real32_T const **sfcnUPtrs = (real32_T const **)
27029 malloc(1 * sizeof(real32_T *));
27030 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27031 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27032 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
27033 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
27034 _ssSetInputPortNumDimensions(childS, 0, 1);
27035 ssSetInputPortWidth(childS, 0, 1);
27036 }
27037
27038 /* port 1 */
27039 {
27040 int8_T const **sfcnUPtrs = (int8_T const **)
27041 malloc(1 * sizeof(int8_T *));
27042 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27043 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
27044 ssGetLocalBlockIO(rts))->DataTypeConversion1_e;
27045 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
27046 _ssSetInputPortNumDimensions(childS, 1, 1);
27047 ssSetInputPortWidth(childS, 1, 1);
27048 }
27049
27050 /* port 2 */
27051 {
27052 real32_T const **sfcnUPtrs = (real32_T const **)
27053 malloc(1 * sizeof(real32_T *));
27054 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27055 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
27056 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
27057 _ssSetInputPortNumDimensions(childS, 2, 1);
27058 ssSetInputPortWidth(childS, 2, 1);
27059 }
27060
27061 /* port 3 */
27062 {
27063 real32_T const **sfcnUPtrs = (real32_T const **)
27064 malloc(1 * sizeof(real32_T *));
27065 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27066 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
27067 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
27068 _ssSetInputPortNumDimensions(childS, 3, 1);
27069 ssSetInputPortWidth(childS, 3, 1);
27070 }
27071
27072 /* port 4 */
27073 {
27074 real32_T const **sfcnUPtrs = (real32_T const **)
27075 malloc(1 * sizeof(real32_T *));
27076 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27077 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27078 ssGetLocalBlockIO(rts))->Switch_jf;
27079 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
27080 _ssSetInputPortNumDimensions(childS, 4, 1);
27081 ssSetInputPortWidth(childS, 4, 1);
27082 }
27083
27084 /* port 5 */
27085 {
27086 real32_T const **sfcnUPtrs = (real32_T const **)
27087 malloc(1 * sizeof(real32_T *));
27088 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27089 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27090 ssGetLocalBlockIO(rts))->Switch_jf;
27091 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
27092 _ssSetInputPortNumDimensions(childS, 5, 1);
27093 ssSetInputPortWidth(childS, 5, 1);
27094 }
27095
27096 /* port 6 */
27097 {
27098 real32_T const **sfcnUPtrs = (real32_T const **)
27099 malloc(1 * sizeof(real32_T *));
27100 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27101 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27102 ssGetLocalBlockIO(rts))->GeneratedSFunction_k5;
27103 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
27104 _ssSetInputPortNumDimensions(childS, 6, 1);
27105 ssSetInputPortWidth(childS, 6, 1);
27106 }
27107 }
27108
27109 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
27110 RegNumOutputPorts);
27111 ssSetRegNumOutputPortsFcnArg(childS,childS);
27112
27113 /* outputs */
27114 {
27115 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
27116 calloc(1, sizeof(struct _ssPortOutputs));
27117 ss_VALIDATE_MEMORY(rts,outputPortInfo);
27118 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
27119 _ssSetNumOutputPorts(childS, 1);
27120
27121 /* port 0 */
27122 {
27123 _ssSetOutputPortNumDimensions(childS, 0, 1);
27124 ssSetOutputPortWidth(childS, 0, 1);
27125 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
27126 ssGetLocalBlockIO(rts))->GeneratedSFunction2_h));
27127 }
27128 }
27129
27130 /* path info */
27131 _ssSetModelName(childS, "LeadLagFilter_sf");
27132 _ssSetPath(childS,
27133 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/Lead lag1/Generated S-Function2");
27134 if (ssGetRTModel(rts) == (NULL)) {
27135 _ssSetParentSS(childS, rts);
27136 _ssSetRootSS(childS, ssGetRootSS(rts));
27137 } else {
27138 ssSetRTModel(childS,ssGetRTModel(rts));
27139 _ssSetParentSS(childS, (NULL));
27140 _ssSetRootSS(childS, childS);
27141 }
27142
27143 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
27144
27145 /* work vectors */
27146 {
27147 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
27148 (4 * sizeof(struct _ssDWorkRecord));
27149 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
27150 calloc(4, sizeof(struct _ssDWorkAuxRecord));
27151 ss_VALIDATE_MEMORY(rts,dWorkRecord);
27152 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
27153 ssSetSFcnDWork(childS, dWorkRecord);
27154 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
27155 _ssSetNumDWork(childS, 4);
27156
27157 /* DWORK0 */
27158 ssSetDWorkWidth(childS, 0, 1);
27159 ssSetDWorkDataType(childS, 0,SS_SINGLE);
27160 ssSetDWorkComplexSignal(childS, 0, 0);
27161 ssSetDWorkUsedAsDState(childS, 0, 1);
27162 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 223))[0]);
27163
27164 /* DWORK1 */
27165 ssSetDWorkWidth(childS, 1, 1);
27166 ssSetDWorkDataType(childS, 1,SS_SINGLE);
27167 ssSetDWorkComplexSignal(childS, 1, 0);
27168 ssSetDWorkUsedAsDState(childS, 1, 1);
27169 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 224))[0]);
27170
27171 /* DWORK2 */
27172 ssSetDWorkWidth(childS, 2, 1);
27173 ssSetDWorkDataType(childS, 2,SS_INT8);
27174 ssSetDWorkComplexSignal(childS, 2, 0);
27175 ssSetDWorkUsedAsDState(childS, 2, 1);
27176 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 450))[0]);
27177
27178 /* DWORK3 */
27179 ssSetDWorkWidth(childS, 3, 1);
27180 ssSetDWorkDataType(childS, 3,SS_INT8);
27181 ssSetDWorkComplexSignal(childS, 3, 0);
27182 ssSetDWorkUsedAsDState(childS, 3, 1);
27183 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 451))[0]);
27184 }
27185
27186 (childS)->regDataType.arg1 = ((void *)(childS));
27187 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
27188 FcnSetErrorStatus);
27189 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
27190 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
27191 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
27192 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
27193
27194 /* registration */
27195#if defined(MATLAB_MEX_FILE)
27196
27197 {
27198 int_T i;
27199 mxArray *plhs[1];
27200 mxArray *prhs[4];
27201 double *pr;
27202 volatile int_T *intS = (int_T *)&childS;
27203 int_T addrlen = sizeof(SimStruct *);
27204 int_T m = addrlen/sizeof(int_T) + 1;
27205 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
27206 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
27207 pr = mxGetPr(prhs[1]);
27208 for (i = 0; i < m - 1; i++) {
27209 pr[i] = (double)intS[i];
27210 }
27211
27212 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
27213 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
27214 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
27215
27216 /* Reset port dimensions info functions because the S-function
27217 * and accelerator mex-files explicitly set their dimensions,
27218 * i.e., they are not dynamically sized. For this case, the
27219 * mex-file is responsible for the dimensions info memory
27220 * and Simulink should not free it. This is achieved by
27221 * setting the following two methods to NULL.
27222 */
27223 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
27224 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
27225
27226 /*
27227 * Setup function pointers and call mdlInitializeSizes via
27228 * simulink.c
27229 */
27230 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
27231 mxDestroyArray(plhs[0]);
27232 mxDestroyArray(prhs[0]);
27233 mxDestroyArray(prhs[1]);
27234 mxDestroyArray(prhs[2]);
27235 mxDestroyArray(prhs[3]);
27236 }
27237
27238#else
27239
27240 {
27241 LeadLagFilter_sf(childS);
27242 sfcnInitializeSizes(childS);
27243 }
27244
27245#endif
27246
27247 sfcnInitializeSampleTimes(childS);
27248
27249 /* adjust sample time */
27250 ssSetSampleTime(childS, 0, 0.0);
27251 ssSetOffsetTime(childS, 0, 0.0);
27252 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
27253
27254 /* set compiled values of dynamic vector attributes */
27255 ssSetNumNonsampledZCs(childS, 0);
27256
27257 /* Update connectivity flags for each port */
27258 _ssSetInputPortConnected(childS, 0, 1);
27259 _ssSetInputPortConnected(childS, 1, 1);
27260 _ssSetInputPortConnected(childS, 2, 1);
27261 _ssSetInputPortConnected(childS, 3, 1);
27262 _ssSetInputPortConnected(childS, 4, 1);
27263 _ssSetInputPortConnected(childS, 5, 1);
27264 _ssSetInputPortConnected(childS, 6, 1);
27265 _ssSetOutputPortConnected(childS, 0, 1);
27266 _ssSetOutputPortBeingMerged(childS, 0, 0);
27267
27268 /* Update the BufferDstPort flags for each input port */
27269 _ssSetInputPortBufferDstPort(childS, 0, -1);
27270 _ssSetInputPortBufferDstPort(childS, 1, -1);
27271 _ssSetInputPortBufferDstPort(childS, 2, -1);
27272 _ssSetInputPortBufferDstPort(childS, 3, -1);
27273 _ssSetInputPortBufferDstPort(childS, 4, -1);
27274 _ssSetInputPortBufferDstPort(childS, 5, -1);
27275 _ssSetInputPortBufferDstPort(childS, 6, -1);
27276 }
27277
27278 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S196>/Generated S-Function4 (LagFilter_sf) */
27279 {
27280 SimStruct *childS = ssGetSFunction(rts, 103);
27281
27282 /* timing info */
27283 time_T *sfcnPeriod;
27284 time_T *sfcnOffset;
27285 int_T *sfcnTsMap;
27286 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
27287 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
27288 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
27289 ss_VALIDATE_MEMORY(rts,sfcnOffset);
27290 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
27291 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
27292 (void) memset((void*)sfcnPeriod, 0,
27293 sizeof(time_T)*1);
27294 (void) memset((void*)sfcnOffset, 0,
27295 sizeof(time_T)*1);
27296 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
27297 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
27298 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
27299
27300 /* Set up the mdlInfo pointer */
27301# ifdef USE_RTMODEL
27302
27303 {
27304 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
27305 struct _ssBlkInfo2));
27306 ss_VALIDATE_MEMORY(rts,blkInfo2);
27307 ssSetBlkInfo2Ptr(childS, blkInfo2);
27308 }
27309
27310 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
27311
27312# else
27313
27314 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
27315
27316# endif /* USE_RTMODEL */
27317
27318 /* Allocate memory of model methods 2 */
27319 {
27320 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
27321 malloc(sizeof(struct _ssSFcnModelMethods2));
27322 ss_VALIDATE_MEMORY(rts,methods2);
27323 ssSetModelMethods2(childS, methods2);
27324 }
27325
27326 /* Allocate memory of model methods 3 */
27327 {
27328 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
27329 malloc(sizeof(struct _ssSFcnModelMethods3));
27330 ss_VALIDATE_MEMORY(rts,methods3);
27331 ssSetModelMethods3(childS, methods3);
27332 }
27333
27334 /* Allocate memory for states auxilliary information */
27335 {
27336 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
27337 (sizeof(struct _ssStatesInfo2));
27338 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
27339 malloc(sizeof(ssPeriodicStatesInfo));
27340 ss_VALIDATE_MEMORY(rts,statesInfo2);
27341 ssSetStatesInfo2(childS, statesInfo2);
27342 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
27343 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
27344 }
27345
27346 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
27347 RegNumInputPorts);
27348 ssSetRegNumInputPortsFcnArg(childS,childS);
27349
27350 /* inputs */
27351 {
27352 struct _ssPortInputs *inputPortInfo =
27353 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
27354 ss_VALIDATE_MEMORY(rts,inputPortInfo);
27355 _ssSetNumInputPorts(childS, 6);
27356 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
27357
27358 /* port 0 */
27359 {
27360 real32_T const **sfcnUPtrs = (real32_T const **)
27361 malloc(1 * sizeof(real32_T *));
27362 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27363 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27364 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
27365 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
27366 _ssSetInputPortNumDimensions(childS, 0, 1);
27367 ssSetInputPortWidth(childS, 0, 1);
27368 }
27369
27370 /* port 1 */
27371 {
27372 int8_T const **sfcnUPtrs = (int8_T const **)
27373 malloc(1 * sizeof(int8_T *));
27374 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27375 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
27376 ssGetLocalBlockIO(rts))->DataTypeConversion1_e;
27377 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
27378 _ssSetInputPortNumDimensions(childS, 1, 1);
27379 ssSetInputPortWidth(childS, 1, 1);
27380 }
27381
27382 /* port 2 */
27383 {
27384 real32_T const **sfcnUPtrs = (real32_T const **)
27385 malloc(1 * sizeof(real32_T *));
27386 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27387 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled124;
27388 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
27389 _ssSetInputPortNumDimensions(childS, 2, 1);
27390 ssSetInputPortWidth(childS, 2, 1);
27391 }
27392
27393 /* port 3 */
27394 {
27395 real32_T const **sfcnUPtrs = (real32_T const **)
27396 malloc(1 * sizeof(real32_T *));
27397 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27398 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27399 ssGetLocalBlockIO(rts))->Switch_jf;
27400 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
27401 _ssSetInputPortNumDimensions(childS, 3, 1);
27402 ssSetInputPortWidth(childS, 3, 1);
27403 }
27404
27405 /* port 4 */
27406 {
27407 real32_T const **sfcnUPtrs = (real32_T const **)
27408 malloc(1 * sizeof(real32_T *));
27409 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27410 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27411 ssGetLocalBlockIO(rts))->Switch_jf;
27412 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
27413 _ssSetInputPortNumDimensions(childS, 4, 1);
27414 ssSetInputPortWidth(childS, 4, 1);
27415 }
27416
27417 /* port 5 */
27418 {
27419 real32_T const **sfcnUPtrs = (real32_T const **)
27420 malloc(1 * sizeof(real32_T *));
27421 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27422 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27423 ssGetLocalBlockIO(rts))->GeneratedSFunction2_h;
27424 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
27425 _ssSetInputPortNumDimensions(childS, 5, 1);
27426 ssSetInputPortWidth(childS, 5, 1);
27427 }
27428 }
27429
27430 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
27431 RegNumOutputPorts);
27432 ssSetRegNumOutputPortsFcnArg(childS,childS);
27433
27434 /* outputs */
27435 {
27436 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
27437 calloc(1, sizeof(struct _ssPortOutputs));
27438 ss_VALIDATE_MEMORY(rts,outputPortInfo);
27439 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
27440 _ssSetNumOutputPorts(childS, 1);
27441
27442 /* port 0 */
27443 {
27444 _ssSetOutputPortNumDimensions(childS, 0, 1);
27445 ssSetOutputPortWidth(childS, 0, 1);
27446 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
27447 ssGetLocalBlockIO(rts))->GeneratedSFunction4_a));
27448 }
27449 }
27450
27451 /* path info */
27452 _ssSetModelName(childS, "LagFilter_sf");
27453 _ssSetPath(childS,
27454 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/PsiControl/ lag filter/Generated S-Function4");
27455 if (ssGetRTModel(rts) == (NULL)) {
27456 _ssSetParentSS(childS, rts);
27457 _ssSetRootSS(childS, ssGetRootSS(rts));
27458 } else {
27459 ssSetRTModel(childS,ssGetRTModel(rts));
27460 _ssSetParentSS(childS, (NULL));
27461 _ssSetRootSS(childS, childS);
27462 }
27463
27464 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
27465
27466 /* work vectors */
27467 {
27468 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
27469 (4 * sizeof(struct _ssDWorkRecord));
27470 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
27471 calloc(4, sizeof(struct _ssDWorkAuxRecord));
27472 ss_VALIDATE_MEMORY(rts,dWorkRecord);
27473 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
27474 ssSetSFcnDWork(childS, dWorkRecord);
27475 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
27476 _ssSetNumDWork(childS, 4);
27477
27478 /* DWORK0 */
27479 ssSetDWorkWidth(childS, 0, 1);
27480 ssSetDWorkDataType(childS, 0,SS_SINGLE);
27481 ssSetDWorkComplexSignal(childS, 0, 0);
27482 ssSetDWorkUsedAsDState(childS, 0, 1);
27483 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 225))[0]);
27484
27485 /* DWORK1 */
27486 ssSetDWorkWidth(childS, 1, 1);
27487 ssSetDWorkDataType(childS, 1,SS_SINGLE);
27488 ssSetDWorkComplexSignal(childS, 1, 0);
27489 ssSetDWorkUsedAsDState(childS, 1, 1);
27490 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 226))[0]);
27491
27492 /* DWORK2 */
27493 ssSetDWorkWidth(childS, 2, 1);
27494 ssSetDWorkDataType(childS, 2,SS_INT8);
27495 ssSetDWorkComplexSignal(childS, 2, 0);
27496 ssSetDWorkUsedAsDState(childS, 2, 1);
27497 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 452))[0]);
27498
27499 /* DWORK3 */
27500 ssSetDWorkWidth(childS, 3, 1);
27501 ssSetDWorkDataType(childS, 3,SS_INT8);
27502 ssSetDWorkComplexSignal(childS, 3, 0);
27503 ssSetDWorkUsedAsDState(childS, 3, 1);
27504 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 453))[0]);
27505 }
27506
27507 (childS)->regDataType.arg1 = ((void *)(childS));
27508 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
27509 FcnSetErrorStatus);
27510 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
27511 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
27512 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
27513 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
27514
27515 /* registration */
27516#if defined(MATLAB_MEX_FILE)
27517
27518 {
27519 int_T i;
27520 mxArray *plhs[1];
27521 mxArray *prhs[4];
27522 double *pr;
27523 volatile int_T *intS = (int_T *)&childS;
27524 int_T addrlen = sizeof(SimStruct *);
27525 int_T m = addrlen/sizeof(int_T) + 1;
27526 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
27527 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
27528 pr = mxGetPr(prhs[1]);
27529 for (i = 0; i < m - 1; i++) {
27530 pr[i] = (double)intS[i];
27531 }
27532
27533 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
27534 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
27535 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
27536
27537 /* Reset port dimensions info functions because the S-function
27538 * and accelerator mex-files explicitly set their dimensions,
27539 * i.e., they are not dynamically sized. For this case, the
27540 * mex-file is responsible for the dimensions info memory
27541 * and Simulink should not free it. This is achieved by
27542 * setting the following two methods to NULL.
27543 */
27544 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
27545 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
27546
27547 /*
27548 * Setup function pointers and call mdlInitializeSizes via
27549 * simulink.c
27550 */
27551 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
27552 mxDestroyArray(plhs[0]);
27553 mxDestroyArray(prhs[0]);
27554 mxDestroyArray(prhs[1]);
27555 mxDestroyArray(prhs[2]);
27556 mxDestroyArray(prhs[3]);
27557 }
27558
27559#else
27560
27561 {
27562 LagFilter_sf(childS);
27563 sfcnInitializeSizes(childS);
27564 }
27565
27566#endif
27567
27568 sfcnInitializeSampleTimes(childS);
27569
27570 /* adjust sample time */
27571 ssSetSampleTime(childS, 0, 0.0);
27572 ssSetOffsetTime(childS, 0, 0.0);
27573 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
27574
27575 /* set compiled values of dynamic vector attributes */
27576 ssSetNumNonsampledZCs(childS, 0);
27577
27578 /* Update connectivity flags for each port */
27579 _ssSetInputPortConnected(childS, 0, 1);
27580 _ssSetInputPortConnected(childS, 1, 1);
27581 _ssSetInputPortConnected(childS, 2, 1);
27582 _ssSetInputPortConnected(childS, 3, 1);
27583 _ssSetInputPortConnected(childS, 4, 1);
27584 _ssSetInputPortConnected(childS, 5, 1);
27585 _ssSetOutputPortConnected(childS, 0, 1);
27586 _ssSetOutputPortBeingMerged(childS, 0, 0);
27587
27588 /* Update the BufferDstPort flags for each input port */
27589 _ssSetInputPortBufferDstPort(childS, 0, -1);
27590 _ssSetInputPortBufferDstPort(childS, 1, -1);
27591 _ssSetInputPortBufferDstPort(childS, 2, -1);
27592 _ssSetInputPortBufferDstPort(childS, 3, -1);
27593 _ssSetInputPortBufferDstPort(childS, 4, -1);
27594 _ssSetInputPortBufferDstPort(childS, 5, -1);
27595 }
27596
27597 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S204>/Generated S-Function (Gain_sf) */
27598 {
27599 SimStruct *childS = ssGetSFunction(rts, 104);
27600
27601 /* timing info */
27602 time_T *sfcnPeriod;
27603 time_T *sfcnOffset;
27604 int_T *sfcnTsMap;
27605 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
27606 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
27607 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
27608 ss_VALIDATE_MEMORY(rts,sfcnOffset);
27609 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
27610 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
27611 (void) memset((void*)sfcnPeriod, 0,
27612 sizeof(time_T)*1);
27613 (void) memset((void*)sfcnOffset, 0,
27614 sizeof(time_T)*1);
27615 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
27616 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
27617 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
27618
27619 /* Set up the mdlInfo pointer */
27620# ifdef USE_RTMODEL
27621
27622 {
27623 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
27624 struct _ssBlkInfo2));
27625 ss_VALIDATE_MEMORY(rts,blkInfo2);
27626 ssSetBlkInfo2Ptr(childS, blkInfo2);
27627 }
27628
27629 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
27630
27631# else
27632
27633 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
27634
27635# endif /* USE_RTMODEL */
27636
27637 /* Allocate memory of model methods 2 */
27638 {
27639 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
27640 malloc(sizeof(struct _ssSFcnModelMethods2));
27641 ss_VALIDATE_MEMORY(rts,methods2);
27642 ssSetModelMethods2(childS, methods2);
27643 }
27644
27645 /* Allocate memory of model methods 3 */
27646 {
27647 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
27648 malloc(sizeof(struct _ssSFcnModelMethods3));
27649 ss_VALIDATE_MEMORY(rts,methods3);
27650 ssSetModelMethods3(childS, methods3);
27651 }
27652
27653 /* Allocate memory for states auxilliary information */
27654 {
27655 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
27656 (sizeof(struct _ssStatesInfo2));
27657 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
27658 malloc(sizeof(ssPeriodicStatesInfo));
27659 ss_VALIDATE_MEMORY(rts,statesInfo2);
27660 ssSetStatesInfo2(childS, statesInfo2);
27661 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
27662 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
27663 }
27664
27665 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
27666 RegNumInputPorts);
27667 ssSetRegNumInputPortsFcnArg(childS,childS);
27668
27669 /* inputs */
27670 {
27671 struct _ssPortInputs *inputPortInfo =
27672 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
27673 ss_VALIDATE_MEMORY(rts,inputPortInfo);
27674 _ssSetNumInputPorts(childS, 2);
27675 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
27676
27677 /* port 0 */
27678 {
27679 real32_T const **sfcnUPtrs = (real32_T const **)
27680 malloc(1 * sizeof(real32_T *));
27681 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27682 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27683 ssGetLocalBlockIO(rts))->r_n;
27684 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
27685 _ssSetInputPortNumDimensions(childS, 0, 1);
27686 ssSetInputPortWidth(childS, 0, 1);
27687 }
27688
27689 /* port 1 */
27690 {
27691 real32_T const **sfcnUPtrs = (real32_T const **)
27692 malloc(1 * sizeof(real32_T *));
27693 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27694 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
27695 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
27696 _ssSetInputPortNumDimensions(childS, 1, 1);
27697 ssSetInputPortWidth(childS, 1, 1);
27698 }
27699 }
27700
27701 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
27702 RegNumOutputPorts);
27703 ssSetRegNumOutputPortsFcnArg(childS,childS);
27704
27705 /* outputs */
27706 {
27707 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
27708 calloc(1, sizeof(struct _ssPortOutputs));
27709 ss_VALIDATE_MEMORY(rts,outputPortInfo);
27710 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
27711 _ssSetNumOutputPorts(childS, 1);
27712
27713 /* port 0 */
27714 {
27715 _ssSetOutputPortNumDimensions(childS, 0, 1);
27716 ssSetOutputPortWidth(childS, 0, 1);
27717 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
27718 ssGetLocalBlockIO(rts))->Saturation8));
27719 }
27720 }
27721
27722 /* path info */
27723 _ssSetModelName(childS, "Gain_sf");
27724 _ssSetPath(childS,
27725 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/gain1/Generated S-Function");
27726 if (ssGetRTModel(rts) == (NULL)) {
27727 _ssSetParentSS(childS, rts);
27728 _ssSetRootSS(childS, ssGetRootSS(rts));
27729 } else {
27730 ssSetRTModel(childS,ssGetRTModel(rts));
27731 _ssSetParentSS(childS, (NULL));
27732 _ssSetRootSS(childS, childS);
27733 }
27734
27735 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
27736 (childS)->regDataType.arg1 = ((void *)(childS));
27737 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
27738 FcnSetErrorStatus);
27739 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
27740 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
27741 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
27742 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
27743
27744 /* registration */
27745#if defined(MATLAB_MEX_FILE)
27746
27747 {
27748 int_T i;
27749 mxArray *plhs[1];
27750 mxArray *prhs[4];
27751 double *pr;
27752 volatile int_T *intS = (int_T *)&childS;
27753 int_T addrlen = sizeof(SimStruct *);
27754 int_T m = addrlen/sizeof(int_T) + 1;
27755 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
27756 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
27757 pr = mxGetPr(prhs[1]);
27758 for (i = 0; i < m - 1; i++) {
27759 pr[i] = (double)intS[i];
27760 }
27761
27762 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
27763 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
27764 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
27765
27766 /* Reset port dimensions info functions because the S-function
27767 * and accelerator mex-files explicitly set their dimensions,
27768 * i.e., they are not dynamically sized. For this case, the
27769 * mex-file is responsible for the dimensions info memory
27770 * and Simulink should not free it. This is achieved by
27771 * setting the following two methods to NULL.
27772 */
27773 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
27774 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
27775
27776 /*
27777 * Setup function pointers and call mdlInitializeSizes via
27778 * simulink.c
27779 */
27780 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
27781 mxDestroyArray(plhs[0]);
27782 mxDestroyArray(prhs[0]);
27783 mxDestroyArray(prhs[1]);
27784 mxDestroyArray(prhs[2]);
27785 mxDestroyArray(prhs[3]);
27786 }
27787
27788#else
27789
27790 {
27791 Gain_sf(childS);
27792 sfcnInitializeSizes(childS);
27793 }
27794
27795#endif
27796
27797 sfcnInitializeSampleTimes(childS);
27798
27799 /* adjust sample time */
27800 ssSetSampleTime(childS, 0, 0.0);
27801 ssSetOffsetTime(childS, 0, 0.0);
27802 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
27803
27804 /* set compiled values of dynamic vector attributes */
27805 ssSetNumNonsampledZCs(childS, 0);
27806
27807 /* Update connectivity flags for each port */
27808 _ssSetInputPortConnected(childS, 0, 1);
27809 _ssSetInputPortConnected(childS, 1, 1);
27810 _ssSetOutputPortConnected(childS, 0, 1);
27811 _ssSetOutputPortBeingMerged(childS, 0, 0);
27812
27813 /* Update the BufferDstPort flags for each input port */
27814 _ssSetInputPortBufferDstPort(childS, 0, -1);
27815 _ssSetInputPortBufferDstPort(childS, 1, -1);
27816 }
27817
27818 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S203>/Generated S-Function1 (SaturationLimiter_sf) */
27819 {
27820 SimStruct *childS = ssGetSFunction(rts, 105);
27821
27822 /* timing info */
27823 time_T *sfcnPeriod;
27824 time_T *sfcnOffset;
27825 int_T *sfcnTsMap;
27826 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
27827 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
27828 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
27829 ss_VALIDATE_MEMORY(rts,sfcnOffset);
27830 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
27831 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
27832 (void) memset((void*)sfcnPeriod, 0,
27833 sizeof(time_T)*1);
27834 (void) memset((void*)sfcnOffset, 0,
27835 sizeof(time_T)*1);
27836 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
27837 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
27838 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
27839
27840 /* Set up the mdlInfo pointer */
27841# ifdef USE_RTMODEL
27842
27843 {
27844 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
27845 struct _ssBlkInfo2));
27846 ss_VALIDATE_MEMORY(rts,blkInfo2);
27847 ssSetBlkInfo2Ptr(childS, blkInfo2);
27848 }
27849
27850 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
27851
27852# else
27853
27854 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
27855
27856# endif /* USE_RTMODEL */
27857
27858 /* Allocate memory of model methods 2 */
27859 {
27860 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
27861 malloc(sizeof(struct _ssSFcnModelMethods2));
27862 ss_VALIDATE_MEMORY(rts,methods2);
27863 ssSetModelMethods2(childS, methods2);
27864 }
27865
27866 /* Allocate memory of model methods 3 */
27867 {
27868 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
27869 malloc(sizeof(struct _ssSFcnModelMethods3));
27870 ss_VALIDATE_MEMORY(rts,methods3);
27871 ssSetModelMethods3(childS, methods3);
27872 }
27873
27874 /* Allocate memory for states auxilliary information */
27875 {
27876 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
27877 (sizeof(struct _ssStatesInfo2));
27878 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
27879 malloc(sizeof(ssPeriodicStatesInfo));
27880 ss_VALIDATE_MEMORY(rts,statesInfo2);
27881 ssSetStatesInfo2(childS, statesInfo2);
27882 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
27883 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
27884 }
27885
27886 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
27887 RegNumInputPorts);
27888 ssSetRegNumInputPortsFcnArg(childS,childS);
27889
27890 /* inputs */
27891 {
27892 struct _ssPortInputs *inputPortInfo =
27893 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
27894 ss_VALIDATE_MEMORY(rts,inputPortInfo);
27895 _ssSetNumInputPorts(childS, 3);
27896 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
27897
27898 /* port 0 */
27899 {
27900 real32_T const **sfcnUPtrs = (real32_T const **)
27901 malloc(1 * sizeof(real32_T *));
27902 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27903 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
27904 ssGetLocalBlockIO(rts))->Sum2_eo;
27905 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
27906 _ssSetInputPortNumDimensions(childS, 0, 1);
27907 ssSetInputPortWidth(childS, 0, 1);
27908 }
27909
27910 /* port 1 */
27911 {
27912 real32_T const **sfcnUPtrs = (real32_T const **)
27913 malloc(1 * sizeof(real32_T *));
27914 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27915 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
27916 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
27917 _ssSetInputPortNumDimensions(childS, 1, 1);
27918 ssSetInputPortWidth(childS, 1, 1);
27919 }
27920
27921 /* port 2 */
27922 {
27923 real32_T const **sfcnUPtrs = (real32_T const **)
27924 malloc(1 * sizeof(real32_T *));
27925 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
27926 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;
27927 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
27928 _ssSetInputPortNumDimensions(childS, 2, 1);
27929 ssSetInputPortWidth(childS, 2, 1);
27930 }
27931 }
27932
27933 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
27934 RegNumOutputPorts);
27935 ssSetRegNumOutputPortsFcnArg(childS,childS);
27936
27937 /* outputs */
27938 {
27939 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
27940 calloc(1, sizeof(struct _ssPortOutputs));
27941 ss_VALIDATE_MEMORY(rts,outputPortInfo);
27942 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
27943 _ssSetNumOutputPorts(childS, 1);
27944
27945 /* port 0 */
27946 {
27947 _ssSetOutputPortNumDimensions(childS, 0, 1);
27948 ssSetOutputPortWidth(childS, 0, 1);
27949 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
27950 ssGetLocalBlockIO(rts))->GeneratedSFunction1_ov));
27951 }
27952 }
27953
27954 /* path info */
27955 _ssSetModelName(childS, "SaturationLimiter_sf");
27956 _ssSetPath(childS,
27957 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/Saturation Limiter3/Generated S-Function1");
27958 if (ssGetRTModel(rts) == (NULL)) {
27959 _ssSetParentSS(childS, rts);
27960 _ssSetRootSS(childS, ssGetRootSS(rts));
27961 } else {
27962 ssSetRTModel(childS,ssGetRTModel(rts));
27963 _ssSetParentSS(childS, (NULL));
27964 _ssSetRootSS(childS, childS);
27965 }
27966
27967 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
27968 (childS)->regDataType.arg1 = ((void *)(childS));
27969 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
27970 FcnSetErrorStatus);
27971 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
27972 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
27973 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
27974 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
27975
27976 /* registration */
27977#if defined(MATLAB_MEX_FILE)
27978
27979 {
27980 int_T i;
27981 mxArray *plhs[1];
27982 mxArray *prhs[4];
27983 double *pr;
27984 volatile int_T *intS = (int_T *)&childS;
27985 int_T addrlen = sizeof(SimStruct *);
27986 int_T m = addrlen/sizeof(int_T) + 1;
27987 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
27988 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
27989 pr = mxGetPr(prhs[1]);
27990 for (i = 0; i < m - 1; i++) {
27991 pr[i] = (double)intS[i];
27992 }
27993
27994 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
27995 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
27996 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
27997
27998 /* Reset port dimensions info functions because the S-function
27999 * and accelerator mex-files explicitly set their dimensions,
28000 * i.e., they are not dynamically sized. For this case, the
28001 * mex-file is responsible for the dimensions info memory
28002 * and Simulink should not free it. This is achieved by
28003 * setting the following two methods to NULL.
28004 */
28005 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
28006 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
28007
28008 /*
28009 * Setup function pointers and call mdlInitializeSizes via
28010 * simulink.c
28011 */
28012 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
28013 mxDestroyArray(plhs[0]);
28014 mxDestroyArray(prhs[0]);
28015 mxDestroyArray(prhs[1]);
28016 mxDestroyArray(prhs[2]);
28017 mxDestroyArray(prhs[3]);
28018 }
28019
28020#else
28021
28022 {
28023 SaturationLimiter_sf(childS);
28024 sfcnInitializeSizes(childS);
28025 }
28026
28027#endif
28028
28029 sfcnInitializeSampleTimes(childS);
28030
28031 /* adjust sample time */
28032 ssSetSampleTime(childS, 0, 0.0);
28033 ssSetOffsetTime(childS, 0, 0.0);
28034 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
28035
28036 /* set compiled values of dynamic vector attributes */
28037 ssSetNumNonsampledZCs(childS, 0);
28038
28039 /* Update connectivity flags for each port */
28040 _ssSetInputPortConnected(childS, 0, 1);
28041 _ssSetInputPortConnected(childS, 1, 1);
28042 _ssSetInputPortConnected(childS, 2, 1);
28043 _ssSetOutputPortConnected(childS, 0, 1);
28044 _ssSetOutputPortBeingMerged(childS, 0, 0);
28045
28046 /* Update the BufferDstPort flags for each input port */
28047 _ssSetInputPortBufferDstPort(childS, 0, -1);
28048 _ssSetInputPortBufferDstPort(childS, 1, -1);
28049 _ssSetInputPortBufferDstPort(childS, 2, -1);
28050 }
28051
28052 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S206>/Generated S-Function (Gain_sf) */
28053 {
28054 SimStruct *childS = ssGetSFunction(rts, 106);
28055
28056 /* timing info */
28057 time_T *sfcnPeriod;
28058 time_T *sfcnOffset;
28059 int_T *sfcnTsMap;
28060 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
28061 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
28062 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
28063 ss_VALIDATE_MEMORY(rts,sfcnOffset);
28064 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
28065 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
28066 (void) memset((void*)sfcnPeriod, 0,
28067 sizeof(time_T)*1);
28068 (void) memset((void*)sfcnOffset, 0,
28069 sizeof(time_T)*1);
28070 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
28071 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
28072 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
28073
28074 /* Set up the mdlInfo pointer */
28075# ifdef USE_RTMODEL
28076
28077 {
28078 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
28079 struct _ssBlkInfo2));
28080 ss_VALIDATE_MEMORY(rts,blkInfo2);
28081 ssSetBlkInfo2Ptr(childS, blkInfo2);
28082 }
28083
28084 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
28085
28086# else
28087
28088 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
28089
28090# endif /* USE_RTMODEL */
28091
28092 /* Allocate memory of model methods 2 */
28093 {
28094 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
28095 malloc(sizeof(struct _ssSFcnModelMethods2));
28096 ss_VALIDATE_MEMORY(rts,methods2);
28097 ssSetModelMethods2(childS, methods2);
28098 }
28099
28100 /* Allocate memory of model methods 3 */
28101 {
28102 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
28103 malloc(sizeof(struct _ssSFcnModelMethods3));
28104 ss_VALIDATE_MEMORY(rts,methods3);
28105 ssSetModelMethods3(childS, methods3);
28106 }
28107
28108 /* Allocate memory for states auxilliary information */
28109 {
28110 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
28111 (sizeof(struct _ssStatesInfo2));
28112 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
28113 malloc(sizeof(ssPeriodicStatesInfo));
28114 ss_VALIDATE_MEMORY(rts,statesInfo2);
28115 ssSetStatesInfo2(childS, statesInfo2);
28116 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
28117 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
28118 }
28119
28120 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
28121 RegNumInputPorts);
28122 ssSetRegNumInputPortsFcnArg(childS,childS);
28123
28124 /* inputs */
28125 {
28126 struct _ssPortInputs *inputPortInfo =
28127 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
28128 ss_VALIDATE_MEMORY(rts,inputPortInfo);
28129 _ssSetNumInputPorts(childS, 2);
28130 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
28131
28132 /* port 0 */
28133 {
28134 real32_T const **sfcnUPtrs = (real32_T const **)
28135 malloc(1 * sizeof(real32_T *));
28136 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
28137 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
28138 ssGetLocalBlockIO(rts))->GeneratedSFunction1_ov;
28139 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
28140 _ssSetInputPortNumDimensions(childS, 0, 1);
28141 ssSetInputPortWidth(childS, 0, 1);
28142 }
28143
28144 /* port 1 */
28145 {
28146 real32_T const **sfcnUPtrs = (real32_T const **)
28147 malloc(1 * sizeof(real32_T *));
28148 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
28149 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
28150 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
28151 _ssSetInputPortNumDimensions(childS, 1, 1);
28152 ssSetInputPortWidth(childS, 1, 1);
28153 }
28154 }
28155
28156 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
28157 RegNumOutputPorts);
28158 ssSetRegNumOutputPortsFcnArg(childS,childS);
28159
28160 /* outputs */
28161 {
28162 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
28163 calloc(1, sizeof(struct _ssPortOutputs));
28164 ss_VALIDATE_MEMORY(rts,outputPortInfo);
28165 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
28166 _ssSetNumOutputPorts(childS, 1);
28167
28168 /* port 0 */
28169 {
28170 _ssSetOutputPortNumDimensions(childS, 0, 1);
28171 ssSetOutputPortWidth(childS, 0, 1);
28172 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
28173 ssGetLocalBlockIO(rts))->MinMax));
28174 }
28175 }
28176
28177 /* path info */
28178 _ssSetModelName(childS, "Gain_sf");
28179 _ssSetPath(childS,
28180 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/gain3/Generated S-Function");
28181 if (ssGetRTModel(rts) == (NULL)) {
28182 _ssSetParentSS(childS, rts);
28183 _ssSetRootSS(childS, ssGetRootSS(rts));
28184 } else {
28185 ssSetRTModel(childS,ssGetRTModel(rts));
28186 _ssSetParentSS(childS, (NULL));
28187 _ssSetRootSS(childS, childS);
28188 }
28189
28190 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
28191 (childS)->regDataType.arg1 = ((void *)(childS));
28192 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
28193 FcnSetErrorStatus);
28194 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
28195 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
28196 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
28197 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
28198
28199 /* registration */
28200#if defined(MATLAB_MEX_FILE)
28201
28202 {
28203 int_T i;
28204 mxArray *plhs[1];
28205 mxArray *prhs[4];
28206 double *pr;
28207 volatile int_T *intS = (int_T *)&childS;
28208 int_T addrlen = sizeof(SimStruct *);
28209 int_T m = addrlen/sizeof(int_T) + 1;
28210 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
28211 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
28212 pr = mxGetPr(prhs[1]);
28213 for (i = 0; i < m - 1; i++) {
28214 pr[i] = (double)intS[i];
28215 }
28216
28217 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
28218 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
28219 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
28220
28221 /* Reset port dimensions info functions because the S-function
28222 * and accelerator mex-files explicitly set their dimensions,
28223 * i.e., they are not dynamically sized. For this case, the
28224 * mex-file is responsible for the dimensions info memory
28225 * and Simulink should not free it. This is achieved by
28226 * setting the following two methods to NULL.
28227 */
28228 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
28229 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
28230
28231 /*
28232 * Setup function pointers and call mdlInitializeSizes via
28233 * simulink.c
28234 */
28235 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
28236 mxDestroyArray(plhs[0]);
28237 mxDestroyArray(prhs[0]);
28238 mxDestroyArray(prhs[1]);
28239 mxDestroyArray(prhs[2]);
28240 mxDestroyArray(prhs[3]);
28241 }
28242
28243#else
28244
28245 {
28246 Gain_sf(childS);
28247 sfcnInitializeSizes(childS);
28248 }
28249
28250#endif
28251
28252 sfcnInitializeSampleTimes(childS);
28253
28254 /* adjust sample time */
28255 ssSetSampleTime(childS, 0, 0.0);
28256 ssSetOffsetTime(childS, 0, 0.0);
28257 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
28258
28259 /* set compiled values of dynamic vector attributes */
28260 ssSetNumNonsampledZCs(childS, 0);
28261
28262 /* Update connectivity flags for each port */
28263 _ssSetInputPortConnected(childS, 0, 1);
28264 _ssSetInputPortConnected(childS, 1, 1);
28265 _ssSetOutputPortConnected(childS, 0, 1);
28266 _ssSetOutputPortBeingMerged(childS, 0, 0);
28267
28268 /* Update the BufferDstPort flags for each input port */
28269 _ssSetInputPortBufferDstPort(childS, 0, -1);
28270 _ssSetInputPortBufferDstPort(childS, 1, -1);
28271 }
28272
28273 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S194>/Generated S-Function6 (Res180_sf) */
28274 {
28275 SimStruct *childS = ssGetSFunction(rts, 107);
28276
28277 /* timing info */
28278 time_T *sfcnPeriod;
28279 time_T *sfcnOffset;
28280 int_T *sfcnTsMap;
28281 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
28282 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
28283 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
28284 ss_VALIDATE_MEMORY(rts,sfcnOffset);
28285 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
28286 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
28287 (void) memset((void*)sfcnPeriod, 0,
28288 sizeof(time_T)*1);
28289 (void) memset((void*)sfcnOffset, 0,
28290 sizeof(time_T)*1);
28291 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
28292 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
28293 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
28294
28295 /* Set up the mdlInfo pointer */
28296# ifdef USE_RTMODEL
28297
28298 {
28299 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
28300 struct _ssBlkInfo2));
28301 ss_VALIDATE_MEMORY(rts,blkInfo2);
28302 ssSetBlkInfo2Ptr(childS, blkInfo2);
28303 }
28304
28305 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
28306
28307# else
28308
28309 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
28310
28311# endif /* USE_RTMODEL */
28312
28313 /* Allocate memory of model methods 2 */
28314 {
28315 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
28316 malloc(sizeof(struct _ssSFcnModelMethods2));
28317 ss_VALIDATE_MEMORY(rts,methods2);
28318 ssSetModelMethods2(childS, methods2);
28319 }
28320
28321 /* Allocate memory of model methods 3 */
28322 {
28323 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
28324 malloc(sizeof(struct _ssSFcnModelMethods3));
28325 ss_VALIDATE_MEMORY(rts,methods3);
28326 ssSetModelMethods3(childS, methods3);
28327 }
28328
28329 /* Allocate memory for states auxilliary information */
28330 {
28331 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
28332 (sizeof(struct _ssStatesInfo2));
28333 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
28334 malloc(sizeof(ssPeriodicStatesInfo));
28335 ss_VALIDATE_MEMORY(rts,statesInfo2);
28336 ssSetStatesInfo2(childS, statesInfo2);
28337 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
28338 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
28339 }
28340
28341 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
28342 RegNumInputPorts);
28343 ssSetRegNumInputPortsFcnArg(childS,childS);
28344
28345 /* inputs */
28346 {
28347 struct _ssPortInputs *inputPortInfo =
28348 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
28349 ss_VALIDATE_MEMORY(rts,inputPortInfo);
28350 _ssSetNumInputPorts(childS, 1);
28351 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
28352
28353 /* port 0 */
28354 {
28355 real32_T const **sfcnUPtrs = (real32_T const **)
28356 malloc(1 * sizeof(real32_T *));
28357 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
28358 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
28359 ssGetLocalBlockIO(rts))->Sum3_k;
28360 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
28361 _ssSetInputPortNumDimensions(childS, 0, 1);
28362 ssSetInputPortWidth(childS, 0, 1);
28363 }
28364 }
28365
28366 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
28367 RegNumOutputPorts);
28368 ssSetRegNumOutputPortsFcnArg(childS,childS);
28369
28370 /* outputs */
28371 {
28372 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
28373 calloc(1, sizeof(struct _ssPortOutputs));
28374 ss_VALIDATE_MEMORY(rts,outputPortInfo);
28375 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
28376 _ssSetNumOutputPorts(childS, 1);
28377
28378 /* port 0 */
28379 {
28380 _ssSetOutputPortNumDimensions(childS, 0, 1);
28381 ssSetOutputPortWidth(childS, 0, 1);
28382 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
28383 ssGetLocalBlockIO(rts))->GeneratedSFunction6_aa));
28384 }
28385 }
28386
28387 /* path info */
28388 _ssSetModelName(childS, "Res180_sf");
28389 _ssSetPath(childS,
28390 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/Generated S-Function6");
28391 if (ssGetRTModel(rts) == (NULL)) {
28392 _ssSetParentSS(childS, rts);
28393 _ssSetRootSS(childS, ssGetRootSS(rts));
28394 } else {
28395 ssSetRTModel(childS,ssGetRTModel(rts));
28396 _ssSetParentSS(childS, (NULL));
28397 _ssSetRootSS(childS, childS);
28398 }
28399
28400 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
28401 (childS)->regDataType.arg1 = ((void *)(childS));
28402 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
28403 FcnSetErrorStatus);
28404 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
28405 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
28406 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
28407 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
28408
28409 /* registration */
28410#if defined(MATLAB_MEX_FILE)
28411
28412 {
28413 int_T i;
28414 mxArray *plhs[1];
28415 mxArray *prhs[4];
28416 double *pr;
28417 volatile int_T *intS = (int_T *)&childS;
28418 int_T addrlen = sizeof(SimStruct *);
28419 int_T m = addrlen/sizeof(int_T) + 1;
28420 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
28421 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
28422 pr = mxGetPr(prhs[1]);
28423 for (i = 0; i < m - 1; i++) {
28424 pr[i] = (double)intS[i];
28425 }
28426
28427 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
28428 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
28429 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
28430
28431 /* Reset port dimensions info functions because the S-function
28432 * and accelerator mex-files explicitly set their dimensions,
28433 * i.e., they are not dynamically sized. For this case, the
28434 * mex-file is responsible for the dimensions info memory
28435 * and Simulink should not free it. This is achieved by
28436 * setting the following two methods to NULL.
28437 */
28438 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
28439 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
28440
28441 /*
28442 * Setup function pointers and call mdlInitializeSizes via
28443 * simulink.c
28444 */
28445 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
28446 mxDestroyArray(plhs[0]);
28447 mxDestroyArray(prhs[0]);
28448 mxDestroyArray(prhs[1]);
28449 mxDestroyArray(prhs[2]);
28450 mxDestroyArray(prhs[3]);
28451 }
28452
28453#else
28454
28455 {
28456 Res180_sf(childS);
28457 sfcnInitializeSizes(childS);
28458 }
28459
28460#endif
28461
28462 sfcnInitializeSampleTimes(childS);
28463
28464 /* adjust sample time */
28465 ssSetSampleTime(childS, 0, 0.0);
28466 ssSetOffsetTime(childS, 0, 0.0);
28467 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
28468
28469 /* set compiled values of dynamic vector attributes */
28470 ssSetNumNonsampledZCs(childS, 0);
28471
28472 /* Update connectivity flags for each port */
28473 _ssSetInputPortConnected(childS, 0, 1);
28474 _ssSetOutputPortConnected(childS, 0, 1);
28475 _ssSetOutputPortBeingMerged(childS, 0, 0);
28476
28477 /* Update the BufferDstPort flags for each input port */
28478 _ssSetInputPortBufferDstPort(childS, 0, -1);
28479 }
28480
28481 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S202>/Generated S-Function1 (SaturationLimiter_sf) */
28482 {
28483 SimStruct *childS = ssGetSFunction(rts, 108);
28484
28485 /* timing info */
28486 time_T *sfcnPeriod;
28487 time_T *sfcnOffset;
28488 int_T *sfcnTsMap;
28489 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
28490 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
28491 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
28492 ss_VALIDATE_MEMORY(rts,sfcnOffset);
28493 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
28494 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
28495 (void) memset((void*)sfcnPeriod, 0,
28496 sizeof(time_T)*1);
28497 (void) memset((void*)sfcnOffset, 0,
28498 sizeof(time_T)*1);
28499 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
28500 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
28501 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
28502
28503 /* Set up the mdlInfo pointer */
28504# ifdef USE_RTMODEL
28505
28506 {
28507 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
28508 struct _ssBlkInfo2));
28509 ss_VALIDATE_MEMORY(rts,blkInfo2);
28510 ssSetBlkInfo2Ptr(childS, blkInfo2);
28511 }
28512
28513 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
28514
28515# else
28516
28517 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
28518
28519# endif /* USE_RTMODEL */
28520
28521 /* Allocate memory of model methods 2 */
28522 {
28523 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
28524 malloc(sizeof(struct _ssSFcnModelMethods2));
28525 ss_VALIDATE_MEMORY(rts,methods2);
28526 ssSetModelMethods2(childS, methods2);
28527 }
28528
28529 /* Allocate memory of model methods 3 */
28530 {
28531 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
28532 malloc(sizeof(struct _ssSFcnModelMethods3));
28533 ss_VALIDATE_MEMORY(rts,methods3);
28534 ssSetModelMethods3(childS, methods3);
28535 }
28536
28537 /* Allocate memory for states auxilliary information */
28538 {
28539 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
28540 (sizeof(struct _ssStatesInfo2));
28541 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
28542 malloc(sizeof(ssPeriodicStatesInfo));
28543 ss_VALIDATE_MEMORY(rts,statesInfo2);
28544 ssSetStatesInfo2(childS, statesInfo2);
28545 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
28546 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
28547 }
28548
28549 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
28550 RegNumInputPorts);
28551 ssSetRegNumInputPortsFcnArg(childS,childS);
28552
28553 /* inputs */
28554 {
28555 struct _ssPortInputs *inputPortInfo =
28556 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
28557 ss_VALIDATE_MEMORY(rts,inputPortInfo);
28558 _ssSetNumInputPorts(childS, 3);
28559 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
28560
28561 /* port 0 */
28562 {
28563 real32_T const **sfcnUPtrs = (real32_T const **)
28564 malloc(1 * sizeof(real32_T *));
28565 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
28566 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
28567 ssGetLocalBlockIO(rts))->GeneratedSFunction6_aa;
28568 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
28569 _ssSetInputPortNumDimensions(childS, 0, 1);
28570 ssSetInputPortWidth(childS, 0, 1);
28571 }
28572
28573 /* port 1 */
28574 {
28575 real32_T const **sfcnUPtrs = (real32_T const **)
28576 malloc(1 * sizeof(real32_T *));
28577 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
28578 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;
28579 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
28580 _ssSetInputPortNumDimensions(childS, 1, 1);
28581 ssSetInputPortWidth(childS, 1, 1);
28582 }
28583
28584 /* port 2 */
28585 {
28586 real32_T const **sfcnUPtrs = (real32_T const **)
28587 malloc(1 * sizeof(real32_T *));
28588 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
28589 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;
28590 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
28591 _ssSetInputPortNumDimensions(childS, 2, 1);
28592 ssSetInputPortWidth(childS, 2, 1);
28593 }
28594 }
28595
28596 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
28597 RegNumOutputPorts);
28598 ssSetRegNumOutputPortsFcnArg(childS,childS);
28599
28600 /* outputs */
28601 {
28602 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
28603 calloc(1, sizeof(struct _ssPortOutputs));
28604 ss_VALIDATE_MEMORY(rts,outputPortInfo);
28605 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
28606 _ssSetNumOutputPorts(childS, 1);
28607
28608 /* port 0 */
28609 {
28610 _ssSetOutputPortNumDimensions(childS, 0, 1);
28611 ssSetOutputPortWidth(childS, 0, 1);
28612 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
28613 ssGetLocalBlockIO(rts))->GeneratedSFunction1_dm));
28614 }
28615 }
28616
28617 /* path info */
28618 _ssSetModelName(childS, "SaturationLimiter_sf");
28619 _ssSetPath(childS,
28620 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/Saturation Limiter1/Generated S-Function1");
28621 if (ssGetRTModel(rts) == (NULL)) {
28622 _ssSetParentSS(childS, rts);
28623 _ssSetRootSS(childS, ssGetRootSS(rts));
28624 } else {
28625 ssSetRTModel(childS,ssGetRTModel(rts));
28626 _ssSetParentSS(childS, (NULL));
28627 _ssSetRootSS(childS, childS);
28628 }
28629
28630 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
28631 (childS)->regDataType.arg1 = ((void *)(childS));
28632 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
28633 FcnSetErrorStatus);
28634 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
28635 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
28636 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
28637 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
28638
28639 /* registration */
28640#if defined(MATLAB_MEX_FILE)
28641
28642 {
28643 int_T i;
28644 mxArray *plhs[1];
28645 mxArray *prhs[4];
28646 double *pr;
28647 volatile int_T *intS = (int_T *)&childS;
28648 int_T addrlen = sizeof(SimStruct *);
28649 int_T m = addrlen/sizeof(int_T) + 1;
28650 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
28651 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
28652 pr = mxGetPr(prhs[1]);
28653 for (i = 0; i < m - 1; i++) {
28654 pr[i] = (double)intS[i];
28655 }
28656
28657 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
28658 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
28659 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
28660
28661 /* Reset port dimensions info functions because the S-function
28662 * and accelerator mex-files explicitly set their dimensions,
28663 * i.e., they are not dynamically sized. For this case, the
28664 * mex-file is responsible for the dimensions info memory
28665 * and Simulink should not free it. This is achieved by
28666 * setting the following two methods to NULL.
28667 */
28668 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
28669 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
28670
28671 /*
28672 * Setup function pointers and call mdlInitializeSizes via
28673 * simulink.c
28674 */
28675 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
28676 mxDestroyArray(plhs[0]);
28677 mxDestroyArray(prhs[0]);
28678 mxDestroyArray(prhs[1]);
28679 mxDestroyArray(prhs[2]);
28680 mxDestroyArray(prhs[3]);
28681 }
28682
28683#else
28684
28685 {
28686 SaturationLimiter_sf(childS);
28687 sfcnInitializeSizes(childS);
28688 }
28689
28690#endif
28691
28692 sfcnInitializeSampleTimes(childS);
28693
28694 /* adjust sample time */
28695 ssSetSampleTime(childS, 0, 0.0);
28696 ssSetOffsetTime(childS, 0, 0.0);
28697 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
28698
28699 /* set compiled values of dynamic vector attributes */
28700 ssSetNumNonsampledZCs(childS, 0);
28701
28702 /* Update connectivity flags for each port */
28703 _ssSetInputPortConnected(childS, 0, 1);
28704 _ssSetInputPortConnected(childS, 1, 1);
28705 _ssSetInputPortConnected(childS, 2, 1);
28706 _ssSetOutputPortConnected(childS, 0, 1);
28707 _ssSetOutputPortBeingMerged(childS, 0, 0);
28708
28709 /* Update the BufferDstPort flags for each input port */
28710 _ssSetInputPortBufferDstPort(childS, 0, -1);
28711 _ssSetInputPortBufferDstPort(childS, 1, -1);
28712 _ssSetInputPortBufferDstPort(childS, 2, -1);
28713 }
28714
28715 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S205>/Generated S-Function (Gain_sf) */
28716 {
28717 SimStruct *childS = ssGetSFunction(rts, 109);
28718
28719 /* timing info */
28720 time_T *sfcnPeriod;
28721 time_T *sfcnOffset;
28722 int_T *sfcnTsMap;
28723 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
28724 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
28725 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
28726 ss_VALIDATE_MEMORY(rts,sfcnOffset);
28727 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
28728 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
28729 (void) memset((void*)sfcnPeriod, 0,
28730 sizeof(time_T)*1);
28731 (void) memset((void*)sfcnOffset, 0,
28732 sizeof(time_T)*1);
28733 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
28734 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
28735 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
28736
28737 /* Set up the mdlInfo pointer */
28738# ifdef USE_RTMODEL
28739
28740 {
28741 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
28742 struct _ssBlkInfo2));
28743 ss_VALIDATE_MEMORY(rts,blkInfo2);
28744 ssSetBlkInfo2Ptr(childS, blkInfo2);
28745 }
28746
28747 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
28748
28749# else
28750
28751 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
28752
28753# endif /* USE_RTMODEL */
28754
28755 /* Allocate memory of model methods 2 */
28756 {
28757 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
28758 malloc(sizeof(struct _ssSFcnModelMethods2));
28759 ss_VALIDATE_MEMORY(rts,methods2);
28760 ssSetModelMethods2(childS, methods2);
28761 }
28762
28763 /* Allocate memory of model methods 3 */
28764 {
28765 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
28766 malloc(sizeof(struct _ssSFcnModelMethods3));
28767 ss_VALIDATE_MEMORY(rts,methods3);
28768 ssSetModelMethods3(childS, methods3);
28769 }
28770
28771 /* Allocate memory for states auxilliary information */
28772 {
28773 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
28774 (sizeof(struct _ssStatesInfo2));
28775 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
28776 malloc(sizeof(ssPeriodicStatesInfo));
28777 ss_VALIDATE_MEMORY(rts,statesInfo2);
28778 ssSetStatesInfo2(childS, statesInfo2);
28779 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
28780 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
28781 }
28782
28783 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
28784 RegNumInputPorts);
28785 ssSetRegNumInputPortsFcnArg(childS,childS);
28786
28787 /* inputs */
28788 {
28789 struct _ssPortInputs *inputPortInfo =
28790 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
28791 ss_VALIDATE_MEMORY(rts,inputPortInfo);
28792 _ssSetNumInputPorts(childS, 2);
28793 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
28794
28795 /* port 0 */
28796 {
28797 real32_T const **sfcnUPtrs = (real32_T const **)
28798 malloc(1 * sizeof(real32_T *));
28799 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
28800 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
28801 ssGetLocalBlockIO(rts))->GeneratedSFunction1_dm;
28802 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
28803 _ssSetInputPortNumDimensions(childS, 0, 1);
28804 ssSetInputPortWidth(childS, 0, 1);
28805 }
28806
28807 /* port 1 */
28808 {
28809 real32_T const **sfcnUPtrs = (real32_T const **)
28810 malloc(1 * sizeof(real32_T *));
28811 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
28812 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
28813 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
28814 _ssSetInputPortNumDimensions(childS, 1, 1);
28815 ssSetInputPortWidth(childS, 1, 1);
28816 }
28817 }
28818
28819 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
28820 RegNumOutputPorts);
28821 ssSetRegNumOutputPortsFcnArg(childS,childS);
28822
28823 /* outputs */
28824 {
28825 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
28826 calloc(1, sizeof(struct _ssPortOutputs));
28827 ss_VALIDATE_MEMORY(rts,outputPortInfo);
28828 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
28829 _ssSetNumOutputPorts(childS, 1);
28830
28831 /* port 0 */
28832 {
28833 _ssSetOutputPortNumDimensions(childS, 0, 1);
28834 ssSetOutputPortWidth(childS, 0, 1);
28835 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
28836 ssGetLocalBlockIO(rts))->GeneratedSFunction_pk));
28837 }
28838 }
28839
28840 /* path info */
28841 _ssSetModelName(childS, "Gain_sf");
28842 _ssSetPath(childS,
28843 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/gain2/Generated S-Function");
28844 if (ssGetRTModel(rts) == (NULL)) {
28845 _ssSetParentSS(childS, rts);
28846 _ssSetRootSS(childS, ssGetRootSS(rts));
28847 } else {
28848 ssSetRTModel(childS,ssGetRTModel(rts));
28849 _ssSetParentSS(childS, (NULL));
28850 _ssSetRootSS(childS, childS);
28851 }
28852
28853 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
28854 (childS)->regDataType.arg1 = ((void *)(childS));
28855 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
28856 FcnSetErrorStatus);
28857 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
28858 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
28859 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
28860 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
28861
28862 /* registration */
28863#if defined(MATLAB_MEX_FILE)
28864
28865 {
28866 int_T i;
28867 mxArray *plhs[1];
28868 mxArray *prhs[4];
28869 double *pr;
28870 volatile int_T *intS = (int_T *)&childS;
28871 int_T addrlen = sizeof(SimStruct *);
28872 int_T m = addrlen/sizeof(int_T) + 1;
28873 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
28874 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
28875 pr = mxGetPr(prhs[1]);
28876 for (i = 0; i < m - 1; i++) {
28877 pr[i] = (double)intS[i];
28878 }
28879
28880 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
28881 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
28882 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
28883
28884 /* Reset port dimensions info functions because the S-function
28885 * and accelerator mex-files explicitly set their dimensions,
28886 * i.e., they are not dynamically sized. For this case, the
28887 * mex-file is responsible for the dimensions info memory
28888 * and Simulink should not free it. This is achieved by
28889 * setting the following two methods to NULL.
28890 */
28891 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
28892 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
28893
28894 /*
28895 * Setup function pointers and call mdlInitializeSizes via
28896 * simulink.c
28897 */
28898 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
28899 mxDestroyArray(plhs[0]);
28900 mxDestroyArray(prhs[0]);
28901 mxDestroyArray(prhs[1]);
28902 mxDestroyArray(prhs[2]);
28903 mxDestroyArray(prhs[3]);
28904 }
28905
28906#else
28907
28908 {
28909 Gain_sf(childS);
28910 sfcnInitializeSizes(childS);
28911 }
28912
28913#endif
28914
28915 sfcnInitializeSampleTimes(childS);
28916
28917 /* adjust sample time */
28918 ssSetSampleTime(childS, 0, 0.0);
28919 ssSetOffsetTime(childS, 0, 0.0);
28920 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
28921
28922 /* set compiled values of dynamic vector attributes */
28923 ssSetNumNonsampledZCs(childS, 0);
28924
28925 /* Update connectivity flags for each port */
28926 _ssSetInputPortConnected(childS, 0, 1);
28927 _ssSetInputPortConnected(childS, 1, 1);
28928 _ssSetOutputPortConnected(childS, 0, 1);
28929 _ssSetOutputPortBeingMerged(childS, 0, 0);
28930
28931 /* Update the BufferDstPort flags for each input port */
28932 _ssSetInputPortBufferDstPort(childS, 0, -1);
28933 _ssSetInputPortBufferDstPort(childS, 1, -1);
28934 }
28935
28936 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S201>/Generated S-Function2 (LeadLagFilter_sf) */
28937 {
28938 SimStruct *childS = ssGetSFunction(rts, 110);
28939
28940 /* timing info */
28941 time_T *sfcnPeriod;
28942 time_T *sfcnOffset;
28943 int_T *sfcnTsMap;
28944 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
28945 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
28946 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
28947 ss_VALIDATE_MEMORY(rts,sfcnOffset);
28948 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
28949 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
28950 (void) memset((void*)sfcnPeriod, 0,
28951 sizeof(time_T)*1);
28952 (void) memset((void*)sfcnOffset, 0,
28953 sizeof(time_T)*1);
28954 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
28955 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
28956 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
28957
28958 /* Set up the mdlInfo pointer */
28959# ifdef USE_RTMODEL
28960
28961 {
28962 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
28963 struct _ssBlkInfo2));
28964 ss_VALIDATE_MEMORY(rts,blkInfo2);
28965 ssSetBlkInfo2Ptr(childS, blkInfo2);
28966 }
28967
28968 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
28969
28970# else
28971
28972 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
28973
28974# endif /* USE_RTMODEL */
28975
28976 /* Allocate memory of model methods 2 */
28977 {
28978 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
28979 malloc(sizeof(struct _ssSFcnModelMethods2));
28980 ss_VALIDATE_MEMORY(rts,methods2);
28981 ssSetModelMethods2(childS, methods2);
28982 }
28983
28984 /* Allocate memory of model methods 3 */
28985 {
28986 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
28987 malloc(sizeof(struct _ssSFcnModelMethods3));
28988 ss_VALIDATE_MEMORY(rts,methods3);
28989 ssSetModelMethods3(childS, methods3);
28990 }
28991
28992 /* Allocate memory for states auxilliary information */
28993 {
28994 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
28995 (sizeof(struct _ssStatesInfo2));
28996 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
28997 malloc(sizeof(ssPeriodicStatesInfo));
28998 ss_VALIDATE_MEMORY(rts,statesInfo2);
28999 ssSetStatesInfo2(childS, statesInfo2);
29000 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
29001 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
29002 }
29003
29004 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
29005 RegNumInputPorts);
29006 ssSetRegNumInputPortsFcnArg(childS,childS);
29007
29008 /* inputs */
29009 {
29010 struct _ssPortInputs *inputPortInfo =
29011 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
29012 ss_VALIDATE_MEMORY(rts,inputPortInfo);
29013 _ssSetNumInputPorts(childS, 7);
29014 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
29015
29016 /* port 0 */
29017 {
29018 real32_T const **sfcnUPtrs = (real32_T const **)
29019 malloc(1 * sizeof(real32_T *));
29020 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29021 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29022 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
29023 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
29024 _ssSetInputPortNumDimensions(childS, 0, 1);
29025 ssSetInputPortWidth(childS, 0, 1);
29026 }
29027
29028 /* port 1 */
29029 {
29030 int8_T const **sfcnUPtrs = (int8_T const **)
29031 malloc(1 * sizeof(int8_T *));
29032 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29033 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
29034 ssGetLocalBlockIO(rts))->DataTypeConversion2_j;
29035 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
29036 _ssSetInputPortNumDimensions(childS, 1, 1);
29037 ssSetInputPortWidth(childS, 1, 1);
29038 }
29039
29040 /* port 2 */
29041 {
29042 real32_T const **sfcnUPtrs = (real32_T const **)
29043 malloc(1 * sizeof(real32_T *));
29044 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29045 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
29046 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
29047 _ssSetInputPortNumDimensions(childS, 2, 1);
29048 ssSetInputPortWidth(childS, 2, 1);
29049 }
29050
29051 /* port 3 */
29052 {
29053 real32_T const **sfcnUPtrs = (real32_T const **)
29054 malloc(1 * sizeof(real32_T *));
29055 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29056 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
29057 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
29058 _ssSetInputPortNumDimensions(childS, 3, 1);
29059 ssSetInputPortWidth(childS, 3, 1);
29060 }
29061
29062 /* port 4 */
29063 {
29064 real32_T const **sfcnUPtrs = (real32_T const **)
29065 malloc(1 * sizeof(real32_T *));
29066 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29067 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29068 ssGetLocalBlockIO(rts))->Switch_jf;
29069 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
29070 _ssSetInputPortNumDimensions(childS, 4, 1);
29071 ssSetInputPortWidth(childS, 4, 1);
29072 }
29073
29074 /* port 5 */
29075 {
29076 real32_T const **sfcnUPtrs = (real32_T const **)
29077 malloc(1 * sizeof(real32_T *));
29078 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29079 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29080 ssGetLocalBlockIO(rts))->Switch_jf;
29081 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
29082 _ssSetInputPortNumDimensions(childS, 5, 1);
29083 ssSetInputPortWidth(childS, 5, 1);
29084 }
29085
29086 /* port 6 */
29087 {
29088 real32_T const **sfcnUPtrs = (real32_T const **)
29089 malloc(1 * sizeof(real32_T *));
29090 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29091 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29092 ssGetLocalBlockIO(rts))->GeneratedSFunction_pk;
29093 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
29094 _ssSetInputPortNumDimensions(childS, 6, 1);
29095 ssSetInputPortWidth(childS, 6, 1);
29096 }
29097 }
29098
29099 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
29100 RegNumOutputPorts);
29101 ssSetRegNumOutputPortsFcnArg(childS,childS);
29102
29103 /* outputs */
29104 {
29105 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
29106 calloc(1, sizeof(struct _ssPortOutputs));
29107 ss_VALIDATE_MEMORY(rts,outputPortInfo);
29108 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
29109 _ssSetNumOutputPorts(childS, 1);
29110
29111 /* port 0 */
29112 {
29113 _ssSetOutputPortNumDimensions(childS, 0, 1);
29114 ssSetOutputPortWidth(childS, 0, 1);
29115 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
29116 ssGetLocalBlockIO(rts))->MinMax));
29117 }
29118 }
29119
29120 /* path info */
29121 _ssSetModelName(childS, "LeadLagFilter_sf");
29122 _ssSetPath(childS,
29123 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/Lead lag1/Generated S-Function2");
29124 if (ssGetRTModel(rts) == (NULL)) {
29125 _ssSetParentSS(childS, rts);
29126 _ssSetRootSS(childS, ssGetRootSS(rts));
29127 } else {
29128 ssSetRTModel(childS,ssGetRTModel(rts));
29129 _ssSetParentSS(childS, (NULL));
29130 _ssSetRootSS(childS, childS);
29131 }
29132
29133 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
29134
29135 /* work vectors */
29136 {
29137 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
29138 (4 * sizeof(struct _ssDWorkRecord));
29139 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
29140 calloc(4, sizeof(struct _ssDWorkAuxRecord));
29141 ss_VALIDATE_MEMORY(rts,dWorkRecord);
29142 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
29143 ssSetSFcnDWork(childS, dWorkRecord);
29144 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
29145 _ssSetNumDWork(childS, 4);
29146
29147 /* DWORK0 */
29148 ssSetDWorkWidth(childS, 0, 1);
29149 ssSetDWorkDataType(childS, 0,SS_SINGLE);
29150 ssSetDWorkComplexSignal(childS, 0, 0);
29151 ssSetDWorkUsedAsDState(childS, 0, 1);
29152 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 227))[0]);
29153
29154 /* DWORK1 */
29155 ssSetDWorkWidth(childS, 1, 1);
29156 ssSetDWorkDataType(childS, 1,SS_SINGLE);
29157 ssSetDWorkComplexSignal(childS, 1, 0);
29158 ssSetDWorkUsedAsDState(childS, 1, 1);
29159 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 228))[0]);
29160
29161 /* DWORK2 */
29162 ssSetDWorkWidth(childS, 2, 1);
29163 ssSetDWorkDataType(childS, 2,SS_INT8);
29164 ssSetDWorkComplexSignal(childS, 2, 0);
29165 ssSetDWorkUsedAsDState(childS, 2, 1);
29166 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 454))[0]);
29167
29168 /* DWORK3 */
29169 ssSetDWorkWidth(childS, 3, 1);
29170 ssSetDWorkDataType(childS, 3,SS_INT8);
29171 ssSetDWorkComplexSignal(childS, 3, 0);
29172 ssSetDWorkUsedAsDState(childS, 3, 1);
29173 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 455))[0]);
29174 }
29175
29176 (childS)->regDataType.arg1 = ((void *)(childS));
29177 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
29178 FcnSetErrorStatus);
29179 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
29180 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
29181 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
29182 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
29183
29184 /* registration */
29185#if defined(MATLAB_MEX_FILE)
29186
29187 {
29188 int_T i;
29189 mxArray *plhs[1];
29190 mxArray *prhs[4];
29191 double *pr;
29192 volatile int_T *intS = (int_T *)&childS;
29193 int_T addrlen = sizeof(SimStruct *);
29194 int_T m = addrlen/sizeof(int_T) + 1;
29195 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
29196 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
29197 pr = mxGetPr(prhs[1]);
29198 for (i = 0; i < m - 1; i++) {
29199 pr[i] = (double)intS[i];
29200 }
29201
29202 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
29203 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
29204 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
29205
29206 /* Reset port dimensions info functions because the S-function
29207 * and accelerator mex-files explicitly set their dimensions,
29208 * i.e., they are not dynamically sized. For this case, the
29209 * mex-file is responsible for the dimensions info memory
29210 * and Simulink should not free it. This is achieved by
29211 * setting the following two methods to NULL.
29212 */
29213 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
29214 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
29215
29216 /*
29217 * Setup function pointers and call mdlInitializeSizes via
29218 * simulink.c
29219 */
29220 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
29221 mxDestroyArray(plhs[0]);
29222 mxDestroyArray(prhs[0]);
29223 mxDestroyArray(prhs[1]);
29224 mxDestroyArray(prhs[2]);
29225 mxDestroyArray(prhs[3]);
29226 }
29227
29228#else
29229
29230 {
29231 LeadLagFilter_sf(childS);
29232 sfcnInitializeSizes(childS);
29233 }
29234
29235#endif
29236
29237 sfcnInitializeSampleTimes(childS);
29238
29239 /* adjust sample time */
29240 ssSetSampleTime(childS, 0, 0.0);
29241 ssSetOffsetTime(childS, 0, 0.0);
29242 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
29243
29244 /* set compiled values of dynamic vector attributes */
29245 ssSetNumNonsampledZCs(childS, 0);
29246
29247 /* Update connectivity flags for each port */
29248 _ssSetInputPortConnected(childS, 0, 1);
29249 _ssSetInputPortConnected(childS, 1, 1);
29250 _ssSetInputPortConnected(childS, 2, 1);
29251 _ssSetInputPortConnected(childS, 3, 1);
29252 _ssSetInputPortConnected(childS, 4, 1);
29253 _ssSetInputPortConnected(childS, 5, 1);
29254 _ssSetInputPortConnected(childS, 6, 1);
29255 _ssSetOutputPortConnected(childS, 0, 1);
29256 _ssSetOutputPortBeingMerged(childS, 0, 0);
29257
29258 /* Update the BufferDstPort flags for each input port */
29259 _ssSetInputPortBufferDstPort(childS, 0, -1);
29260 _ssSetInputPortBufferDstPort(childS, 1, -1);
29261 _ssSetInputPortBufferDstPort(childS, 2, -1);
29262 _ssSetInputPortBufferDstPort(childS, 3, -1);
29263 _ssSetInputPortBufferDstPort(childS, 4, -1);
29264 _ssSetInputPortBufferDstPort(childS, 5, -1);
29265 _ssSetInputPortBufferDstPort(childS, 6, -1);
29266 }
29267
29268 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S200>/Generated S-Function4 (LagFilter_sf) */
29269 {
29270 SimStruct *childS = ssGetSFunction(rts, 111);
29271
29272 /* timing info */
29273 time_T *sfcnPeriod;
29274 time_T *sfcnOffset;
29275 int_T *sfcnTsMap;
29276 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
29277 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
29278 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
29279 ss_VALIDATE_MEMORY(rts,sfcnOffset);
29280 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
29281 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
29282 (void) memset((void*)sfcnPeriod, 0,
29283 sizeof(time_T)*1);
29284 (void) memset((void*)sfcnOffset, 0,
29285 sizeof(time_T)*1);
29286 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
29287 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
29288 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
29289
29290 /* Set up the mdlInfo pointer */
29291# ifdef USE_RTMODEL
29292
29293 {
29294 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
29295 struct _ssBlkInfo2));
29296 ss_VALIDATE_MEMORY(rts,blkInfo2);
29297 ssSetBlkInfo2Ptr(childS, blkInfo2);
29298 }
29299
29300 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
29301
29302# else
29303
29304 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
29305
29306# endif /* USE_RTMODEL */
29307
29308 /* Allocate memory of model methods 2 */
29309 {
29310 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
29311 malloc(sizeof(struct _ssSFcnModelMethods2));
29312 ss_VALIDATE_MEMORY(rts,methods2);
29313 ssSetModelMethods2(childS, methods2);
29314 }
29315
29316 /* Allocate memory of model methods 3 */
29317 {
29318 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
29319 malloc(sizeof(struct _ssSFcnModelMethods3));
29320 ss_VALIDATE_MEMORY(rts,methods3);
29321 ssSetModelMethods3(childS, methods3);
29322 }
29323
29324 /* Allocate memory for states auxilliary information */
29325 {
29326 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
29327 (sizeof(struct _ssStatesInfo2));
29328 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
29329 malloc(sizeof(ssPeriodicStatesInfo));
29330 ss_VALIDATE_MEMORY(rts,statesInfo2);
29331 ssSetStatesInfo2(childS, statesInfo2);
29332 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
29333 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
29334 }
29335
29336 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
29337 RegNumInputPorts);
29338 ssSetRegNumInputPortsFcnArg(childS,childS);
29339
29340 /* inputs */
29341 {
29342 struct _ssPortInputs *inputPortInfo =
29343 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
29344 ss_VALIDATE_MEMORY(rts,inputPortInfo);
29345 _ssSetNumInputPorts(childS, 6);
29346 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
29347
29348 /* port 0 */
29349 {
29350 real32_T const **sfcnUPtrs = (real32_T const **)
29351 malloc(1 * sizeof(real32_T *));
29352 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29353 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29354 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
29355 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
29356 _ssSetInputPortNumDimensions(childS, 0, 1);
29357 ssSetInputPortWidth(childS, 0, 1);
29358 }
29359
29360 /* port 1 */
29361 {
29362 int8_T const **sfcnUPtrs = (int8_T const **)
29363 malloc(1 * sizeof(int8_T *));
29364 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29365 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
29366 ssGetLocalBlockIO(rts))->DataTypeConversion2_j;
29367 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
29368 _ssSetInputPortNumDimensions(childS, 1, 1);
29369 ssSetInputPortWidth(childS, 1, 1);
29370 }
29371
29372 /* port 2 */
29373 {
29374 real32_T const **sfcnUPtrs = (real32_T const **)
29375 malloc(1 * sizeof(real32_T *));
29376 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29377 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled124;
29378 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
29379 _ssSetInputPortNumDimensions(childS, 2, 1);
29380 ssSetInputPortWidth(childS, 2, 1);
29381 }
29382
29383 /* port 3 */
29384 {
29385 real32_T const **sfcnUPtrs = (real32_T const **)
29386 malloc(1 * sizeof(real32_T *));
29387 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29388 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29389 ssGetLocalBlockIO(rts))->Switch_jf;
29390 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
29391 _ssSetInputPortNumDimensions(childS, 3, 1);
29392 ssSetInputPortWidth(childS, 3, 1);
29393 }
29394
29395 /* port 4 */
29396 {
29397 real32_T const **sfcnUPtrs = (real32_T const **)
29398 malloc(1 * sizeof(real32_T *));
29399 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29400 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29401 ssGetLocalBlockIO(rts))->Switch_jf;
29402 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
29403 _ssSetInputPortNumDimensions(childS, 4, 1);
29404 ssSetInputPortWidth(childS, 4, 1);
29405 }
29406
29407 /* port 5 */
29408 {
29409 real32_T const **sfcnUPtrs = (real32_T const **)
29410 malloc(1 * sizeof(real32_T *));
29411 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29412 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29413 ssGetLocalBlockIO(rts))->Sum1_k;
29414 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
29415 _ssSetInputPortNumDimensions(childS, 5, 1);
29416 ssSetInputPortWidth(childS, 5, 1);
29417 }
29418 }
29419
29420 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
29421 RegNumOutputPorts);
29422 ssSetRegNumOutputPortsFcnArg(childS,childS);
29423
29424 /* outputs */
29425 {
29426 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
29427 calloc(1, sizeof(struct _ssPortOutputs));
29428 ss_VALIDATE_MEMORY(rts,outputPortInfo);
29429 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
29430 _ssSetNumOutputPorts(childS, 1);
29431
29432 /* port 0 */
29433 {
29434 _ssSetOutputPortNumDimensions(childS, 0, 1);
29435 ssSetOutputPortWidth(childS, 0, 1);
29436 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
29437 ssGetLocalBlockIO(rts))->GeneratedSFunction4_j));
29438 }
29439 }
29440
29441 /* path info */
29442 _ssSetModelName(childS, "LagFilter_sf");
29443 _ssSetPath(childS,
29444 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/apycLcontrol/RwyLControl/ lag filter/Generated S-Function4");
29445 if (ssGetRTModel(rts) == (NULL)) {
29446 _ssSetParentSS(childS, rts);
29447 _ssSetRootSS(childS, ssGetRootSS(rts));
29448 } else {
29449 ssSetRTModel(childS,ssGetRTModel(rts));
29450 _ssSetParentSS(childS, (NULL));
29451 _ssSetRootSS(childS, childS);
29452 }
29453
29454 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
29455
29456 /* work vectors */
29457 {
29458 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
29459 (4 * sizeof(struct _ssDWorkRecord));
29460 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
29461 calloc(4, sizeof(struct _ssDWorkAuxRecord));
29462 ss_VALIDATE_MEMORY(rts,dWorkRecord);
29463 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
29464 ssSetSFcnDWork(childS, dWorkRecord);
29465 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
29466 _ssSetNumDWork(childS, 4);
29467
29468 /* DWORK0 */
29469 ssSetDWorkWidth(childS, 0, 1);
29470 ssSetDWorkDataType(childS, 0,SS_SINGLE);
29471 ssSetDWorkComplexSignal(childS, 0, 0);
29472 ssSetDWorkUsedAsDState(childS, 0, 1);
29473 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 229))[0]);
29474
29475 /* DWORK1 */
29476 ssSetDWorkWidth(childS, 1, 1);
29477 ssSetDWorkDataType(childS, 1,SS_SINGLE);
29478 ssSetDWorkComplexSignal(childS, 1, 0);
29479 ssSetDWorkUsedAsDState(childS, 1, 1);
29480 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 230))[0]);
29481
29482 /* DWORK2 */
29483 ssSetDWorkWidth(childS, 2, 1);
29484 ssSetDWorkDataType(childS, 2,SS_INT8);
29485 ssSetDWorkComplexSignal(childS, 2, 0);
29486 ssSetDWorkUsedAsDState(childS, 2, 1);
29487 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 456))[0]);
29488
29489 /* DWORK3 */
29490 ssSetDWorkWidth(childS, 3, 1);
29491 ssSetDWorkDataType(childS, 3,SS_INT8);
29492 ssSetDWorkComplexSignal(childS, 3, 0);
29493 ssSetDWorkUsedAsDState(childS, 3, 1);
29494 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 457))[0]);
29495 }
29496
29497 (childS)->regDataType.arg1 = ((void *)(childS));
29498 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
29499 FcnSetErrorStatus);
29500 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
29501 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
29502 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
29503 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
29504
29505 /* registration */
29506#if defined(MATLAB_MEX_FILE)
29507
29508 {
29509 int_T i;
29510 mxArray *plhs[1];
29511 mxArray *prhs[4];
29512 double *pr;
29513 volatile int_T *intS = (int_T *)&childS;
29514 int_T addrlen = sizeof(SimStruct *);
29515 int_T m = addrlen/sizeof(int_T) + 1;
29516 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
29517 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
29518 pr = mxGetPr(prhs[1]);
29519 for (i = 0; i < m - 1; i++) {
29520 pr[i] = (double)intS[i];
29521 }
29522
29523 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
29524 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
29525 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
29526
29527 /* Reset port dimensions info functions because the S-function
29528 * and accelerator mex-files explicitly set their dimensions,
29529 * i.e., they are not dynamically sized. For this case, the
29530 * mex-file is responsible for the dimensions info memory
29531 * and Simulink should not free it. This is achieved by
29532 * setting the following two methods to NULL.
29533 */
29534 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
29535 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
29536
29537 /*
29538 * Setup function pointers and call mdlInitializeSizes via
29539 * simulink.c
29540 */
29541 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
29542 mxDestroyArray(plhs[0]);
29543 mxDestroyArray(prhs[0]);
29544 mxDestroyArray(prhs[1]);
29545 mxDestroyArray(prhs[2]);
29546 mxDestroyArray(prhs[3]);
29547 }
29548
29549#else
29550
29551 {
29552 LagFilter_sf(childS);
29553 sfcnInitializeSizes(childS);
29554 }
29555
29556#endif
29557
29558 sfcnInitializeSampleTimes(childS);
29559
29560 /* adjust sample time */
29561 ssSetSampleTime(childS, 0, 0.0);
29562 ssSetOffsetTime(childS, 0, 0.0);
29563 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
29564
29565 /* set compiled values of dynamic vector attributes */
29566 ssSetNumNonsampledZCs(childS, 0);
29567
29568 /* Update connectivity flags for each port */
29569 _ssSetInputPortConnected(childS, 0, 1);
29570 _ssSetInputPortConnected(childS, 1, 1);
29571 _ssSetInputPortConnected(childS, 2, 1);
29572 _ssSetInputPortConnected(childS, 3, 1);
29573 _ssSetInputPortConnected(childS, 4, 1);
29574 _ssSetInputPortConnected(childS, 5, 1);
29575 _ssSetOutputPortConnected(childS, 0, 1);
29576 _ssSetOutputPortBeingMerged(childS, 0, 0);
29577
29578 /* Update the BufferDstPort flags for each input port */
29579 _ssSetInputPortBufferDstPort(childS, 0, -1);
29580 _ssSetInputPortBufferDstPort(childS, 1, -1);
29581 _ssSetInputPortBufferDstPort(childS, 2, -1);
29582 _ssSetInputPortBufferDstPort(childS, 3, -1);
29583 _ssSetInputPortBufferDstPort(childS, 4, -1);
29584 _ssSetInputPortBufferDstPort(childS, 5, -1);
29585 }
29586
29587 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S69>/Generated S-Function4 (LagFilter_sf) */
29588 {
29589 SimStruct *childS = ssGetSFunction(rts, 112);
29590
29591 /* timing info */
29592 time_T *sfcnPeriod;
29593 time_T *sfcnOffset;
29594 int_T *sfcnTsMap;
29595 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
29596 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
29597 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
29598 ss_VALIDATE_MEMORY(rts,sfcnOffset);
29599 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
29600 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
29601 (void) memset((void*)sfcnPeriod, 0,
29602 sizeof(time_T)*1);
29603 (void) memset((void*)sfcnOffset, 0,
29604 sizeof(time_T)*1);
29605 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
29606 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
29607 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
29608
29609 /* Set up the mdlInfo pointer */
29610# ifdef USE_RTMODEL
29611
29612 {
29613 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
29614 struct _ssBlkInfo2));
29615 ss_VALIDATE_MEMORY(rts,blkInfo2);
29616 ssSetBlkInfo2Ptr(childS, blkInfo2);
29617 }
29618
29619 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
29620
29621# else
29622
29623 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
29624
29625# endif /* USE_RTMODEL */
29626
29627 /* Allocate memory of model methods 2 */
29628 {
29629 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
29630 malloc(sizeof(struct _ssSFcnModelMethods2));
29631 ss_VALIDATE_MEMORY(rts,methods2);
29632 ssSetModelMethods2(childS, methods2);
29633 }
29634
29635 /* Allocate memory of model methods 3 */
29636 {
29637 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
29638 malloc(sizeof(struct _ssSFcnModelMethods3));
29639 ss_VALIDATE_MEMORY(rts,methods3);
29640 ssSetModelMethods3(childS, methods3);
29641 }
29642
29643 /* Allocate memory for states auxilliary information */
29644 {
29645 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
29646 (sizeof(struct _ssStatesInfo2));
29647 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
29648 malloc(sizeof(ssPeriodicStatesInfo));
29649 ss_VALIDATE_MEMORY(rts,statesInfo2);
29650 ssSetStatesInfo2(childS, statesInfo2);
29651 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
29652 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
29653 }
29654
29655 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
29656 RegNumInputPorts);
29657 ssSetRegNumInputPortsFcnArg(childS,childS);
29658
29659 /* inputs */
29660 {
29661 struct _ssPortInputs *inputPortInfo =
29662 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
29663 ss_VALIDATE_MEMORY(rts,inputPortInfo);
29664 _ssSetNumInputPorts(childS, 6);
29665 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
29666
29667 /* port 0 */
29668 {
29669 real32_T const **sfcnUPtrs = (real32_T const **)
29670 malloc(1 * sizeof(real32_T *));
29671 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29672 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29673 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
29674 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
29675 _ssSetInputPortNumDimensions(childS, 0, 1);
29676 ssSetInputPortWidth(childS, 0, 1);
29677 }
29678
29679 /* port 1 */
29680 {
29681 int8_T const **sfcnUPtrs = (int8_T const **)
29682 malloc(1 * sizeof(int8_T *));
29683 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29684 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
29685 ssGetLocalBlockIO(rts))->DataTypeConversion_p;
29686 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
29687 _ssSetInputPortNumDimensions(childS, 1, 1);
29688 ssSetInputPortWidth(childS, 1, 1);
29689 }
29690
29691 /* port 2 */
29692 {
29693 real32_T const **sfcnUPtrs = (real32_T const **)
29694 malloc(1 * sizeof(real32_T *));
29695 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29696 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
29697 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
29698 _ssSetInputPortNumDimensions(childS, 2, 1);
29699 ssSetInputPortWidth(childS, 2, 1);
29700 }
29701
29702 /* port 3 */
29703 {
29704 real32_T const **sfcnUPtrs = (real32_T const **)
29705 malloc(1 * sizeof(real32_T *));
29706 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29707 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29708 ssGetLocalBlockIO(rts))->Switch_fz;
29709 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
29710 _ssSetInputPortNumDimensions(childS, 3, 1);
29711 ssSetInputPortWidth(childS, 3, 1);
29712 }
29713
29714 /* port 4 */
29715 {
29716 real32_T const **sfcnUPtrs = (real32_T const **)
29717 malloc(1 * sizeof(real32_T *));
29718 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29719 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29720 ssGetLocalBlockIO(rts))->Switch_fz;
29721 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
29722 _ssSetInputPortNumDimensions(childS, 4, 1);
29723 ssSetInputPortWidth(childS, 4, 1);
29724 }
29725
29726 /* port 5 */
29727 {
29728 real32_T const **sfcnUPtrs = (real32_T const **)
29729 malloc(1 * sizeof(real32_T *));
29730 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29731 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
29732 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
29733 _ssSetInputPortNumDimensions(childS, 5, 1);
29734 ssSetInputPortWidth(childS, 5, 1);
29735 }
29736 }
29737
29738 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
29739 RegNumOutputPorts);
29740 ssSetRegNumOutputPortsFcnArg(childS,childS);
29741
29742 /* outputs */
29743 {
29744 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
29745 calloc(1, sizeof(struct _ssPortOutputs));
29746 ss_VALIDATE_MEMORY(rts,outputPortInfo);
29747 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
29748 _ssSetNumOutputPorts(childS, 1);
29749
29750 /* port 0 */
29751 {
29752 _ssSetOutputPortNumDimensions(childS, 0, 1);
29753 ssSetOutputPortWidth(childS, 0, 1);
29754 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
29755 ssGetLocalBlockIO(rts))->GeneratedSFunction4_pd));
29756 }
29757 }
29758
29759 /* path info */
29760 _ssSetModelName(childS, "LagFilter_sf");
29761 _ssSetPath(childS,
29762 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/ lag filter/Generated S-Function4");
29763 if (ssGetRTModel(rts) == (NULL)) {
29764 _ssSetParentSS(childS, rts);
29765 _ssSetRootSS(childS, ssGetRootSS(rts));
29766 } else {
29767 ssSetRTModel(childS,ssGetRTModel(rts));
29768 _ssSetParentSS(childS, (NULL));
29769 _ssSetRootSS(childS, childS);
29770 }
29771
29772 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
29773
29774 /* work vectors */
29775 {
29776 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
29777 (4 * sizeof(struct _ssDWorkRecord));
29778 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
29779 calloc(4, sizeof(struct _ssDWorkAuxRecord));
29780 ss_VALIDATE_MEMORY(rts,dWorkRecord);
29781 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
29782 ssSetSFcnDWork(childS, dWorkRecord);
29783 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
29784 _ssSetNumDWork(childS, 4);
29785
29786 /* DWORK0 */
29787 ssSetDWorkWidth(childS, 0, 1);
29788 ssSetDWorkDataType(childS, 0,SS_SINGLE);
29789 ssSetDWorkComplexSignal(childS, 0, 0);
29790 ssSetDWorkUsedAsDState(childS, 0, 1);
29791 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 232))[0]);
29792
29793 /* DWORK1 */
29794 ssSetDWorkWidth(childS, 1, 1);
29795 ssSetDWorkDataType(childS, 1,SS_SINGLE);
29796 ssSetDWorkComplexSignal(childS, 1, 0);
29797 ssSetDWorkUsedAsDState(childS, 1, 1);
29798 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 233))[0]);
29799
29800 /* DWORK2 */
29801 ssSetDWorkWidth(childS, 2, 1);
29802 ssSetDWorkDataType(childS, 2,SS_INT8);
29803 ssSetDWorkComplexSignal(childS, 2, 0);
29804 ssSetDWorkUsedAsDState(childS, 2, 1);
29805 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 459))[0]);
29806
29807 /* DWORK3 */
29808 ssSetDWorkWidth(childS, 3, 1);
29809 ssSetDWorkDataType(childS, 3,SS_INT8);
29810 ssSetDWorkComplexSignal(childS, 3, 0);
29811 ssSetDWorkUsedAsDState(childS, 3, 1);
29812 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 460))[0]);
29813 }
29814
29815 (childS)->regDataType.arg1 = ((void *)(childS));
29816 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
29817 FcnSetErrorStatus);
29818 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
29819 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
29820 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
29821 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
29822
29823 /* registration */
29824#if defined(MATLAB_MEX_FILE)
29825
29826 {
29827 int_T i;
29828 mxArray *plhs[1];
29829 mxArray *prhs[4];
29830 double *pr;
29831 volatile int_T *intS = (int_T *)&childS;
29832 int_T addrlen = sizeof(SimStruct *);
29833 int_T m = addrlen/sizeof(int_T) + 1;
29834 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
29835 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
29836 pr = mxGetPr(prhs[1]);
29837 for (i = 0; i < m - 1; i++) {
29838 pr[i] = (double)intS[i];
29839 }
29840
29841 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
29842 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
29843 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
29844
29845 /* Reset port dimensions info functions because the S-function
29846 * and accelerator mex-files explicitly set their dimensions,
29847 * i.e., they are not dynamically sized. For this case, the
29848 * mex-file is responsible for the dimensions info memory
29849 * and Simulink should not free it. This is achieved by
29850 * setting the following two methods to NULL.
29851 */
29852 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
29853 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
29854
29855 /*
29856 * Setup function pointers and call mdlInitializeSizes via
29857 * simulink.c
29858 */
29859 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
29860 mxDestroyArray(plhs[0]);
29861 mxDestroyArray(prhs[0]);
29862 mxDestroyArray(prhs[1]);
29863 mxDestroyArray(prhs[2]);
29864 mxDestroyArray(prhs[3]);
29865 }
29866
29867#else
29868
29869 {
29870 LagFilter_sf(childS);
29871 sfcnInitializeSizes(childS);
29872 }
29873
29874#endif
29875
29876 sfcnInitializeSampleTimes(childS);
29877
29878 /* adjust sample time */
29879 ssSetSampleTime(childS, 0, 0.0);
29880 ssSetOffsetTime(childS, 0, 0.0);
29881 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
29882
29883 /* set compiled values of dynamic vector attributes */
29884 ssSetNumNonsampledZCs(childS, 0);
29885
29886 /* Update connectivity flags for each port */
29887 _ssSetInputPortConnected(childS, 0, 1);
29888 _ssSetInputPortConnected(childS, 1, 1);
29889 _ssSetInputPortConnected(childS, 2, 1);
29890 _ssSetInputPortConnected(childS, 3, 1);
29891 _ssSetInputPortConnected(childS, 4, 1);
29892 _ssSetInputPortConnected(childS, 5, 1);
29893 _ssSetOutputPortConnected(childS, 0, 1);
29894 _ssSetOutputPortBeingMerged(childS, 0, 0);
29895
29896 /* Update the BufferDstPort flags for each input port */
29897 _ssSetInputPortBufferDstPort(childS, 0, -1);
29898 _ssSetInputPortBufferDstPort(childS, 1, -1);
29899 _ssSetInputPortBufferDstPort(childS, 2, -1);
29900 _ssSetInputPortBufferDstPort(childS, 3, -1);
29901 _ssSetInputPortBufferDstPort(childS, 4, -1);
29902 _ssSetInputPortBufferDstPort(childS, 5, -1);
29903 }
29904
29905 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S70>/Generated S-Function4 (LagFilter_sf) */
29906 {
29907 SimStruct *childS = ssGetSFunction(rts, 113);
29908
29909 /* timing info */
29910 time_T *sfcnPeriod;
29911 time_T *sfcnOffset;
29912 int_T *sfcnTsMap;
29913 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
29914 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
29915 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
29916 ss_VALIDATE_MEMORY(rts,sfcnOffset);
29917 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
29918 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
29919 (void) memset((void*)sfcnPeriod, 0,
29920 sizeof(time_T)*1);
29921 (void) memset((void*)sfcnOffset, 0,
29922 sizeof(time_T)*1);
29923 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
29924 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
29925 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
29926
29927 /* Set up the mdlInfo pointer */
29928# ifdef USE_RTMODEL
29929
29930 {
29931 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
29932 struct _ssBlkInfo2));
29933 ss_VALIDATE_MEMORY(rts,blkInfo2);
29934 ssSetBlkInfo2Ptr(childS, blkInfo2);
29935 }
29936
29937 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
29938
29939# else
29940
29941 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
29942
29943# endif /* USE_RTMODEL */
29944
29945 /* Allocate memory of model methods 2 */
29946 {
29947 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
29948 malloc(sizeof(struct _ssSFcnModelMethods2));
29949 ss_VALIDATE_MEMORY(rts,methods2);
29950 ssSetModelMethods2(childS, methods2);
29951 }
29952
29953 /* Allocate memory of model methods 3 */
29954 {
29955 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
29956 malloc(sizeof(struct _ssSFcnModelMethods3));
29957 ss_VALIDATE_MEMORY(rts,methods3);
29958 ssSetModelMethods3(childS, methods3);
29959 }
29960
29961 /* Allocate memory for states auxilliary information */
29962 {
29963 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
29964 (sizeof(struct _ssStatesInfo2));
29965 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
29966 malloc(sizeof(ssPeriodicStatesInfo));
29967 ss_VALIDATE_MEMORY(rts,statesInfo2);
29968 ssSetStatesInfo2(childS, statesInfo2);
29969 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
29970 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
29971 }
29972
29973 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
29974 RegNumInputPorts);
29975 ssSetRegNumInputPortsFcnArg(childS,childS);
29976
29977 /* inputs */
29978 {
29979 struct _ssPortInputs *inputPortInfo =
29980 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
29981 ss_VALIDATE_MEMORY(rts,inputPortInfo);
29982 _ssSetNumInputPorts(childS, 6);
29983 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
29984
29985 /* port 0 */
29986 {
29987 real32_T const **sfcnUPtrs = (real32_T const **)
29988 malloc(1 * sizeof(real32_T *));
29989 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
29990 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
29991 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
29992 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
29993 _ssSetInputPortNumDimensions(childS, 0, 1);
29994 ssSetInputPortWidth(childS, 0, 1);
29995 }
29996
29997 /* port 1 */
29998 {
29999 int8_T const **sfcnUPtrs = (int8_T const **)
30000 malloc(1 * sizeof(int8_T *));
30001 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30002 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
30003 ssGetLocalBlockIO(rts))->DataTypeConversion2_b;
30004 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
30005 _ssSetInputPortNumDimensions(childS, 1, 1);
30006 ssSetInputPortWidth(childS, 1, 1);
30007 }
30008
30009 /* port 2 */
30010 {
30011 real32_T const **sfcnUPtrs = (real32_T const **)
30012 malloc(1 * sizeof(real32_T *));
30013 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30014 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
30015 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
30016 _ssSetInputPortNumDimensions(childS, 2, 1);
30017 ssSetInputPortWidth(childS, 2, 1);
30018 }
30019
30020 /* port 3 */
30021 {
30022 real32_T const **sfcnUPtrs = (real32_T const **)
30023 malloc(1 * sizeof(real32_T *));
30024 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30025 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
30026 ssGetLocalBlockIO(rts))->Switch_fz;
30027 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
30028 _ssSetInputPortNumDimensions(childS, 3, 1);
30029 ssSetInputPortWidth(childS, 3, 1);
30030 }
30031
30032 /* port 4 */
30033 {
30034 real32_T const **sfcnUPtrs = (real32_T const **)
30035 malloc(1 * sizeof(real32_T *));
30036 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30037 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
30038 ssGetLocalBlockIO(rts))->Switch_fz;
30039 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
30040 _ssSetInputPortNumDimensions(childS, 4, 1);
30041 ssSetInputPortWidth(childS, 4, 1);
30042 }
30043
30044 /* port 5 */
30045 {
30046 real32_T const **sfcnUPtrs = (real32_T const **)
30047 malloc(1 * sizeof(real32_T *));
30048 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30049 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
30050 ssGetLocalBlockIO(rts))->Gain_k;
30051 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
30052 _ssSetInputPortNumDimensions(childS, 5, 1);
30053 ssSetInputPortWidth(childS, 5, 1);
30054 }
30055 }
30056
30057 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
30058 RegNumOutputPorts);
30059 ssSetRegNumOutputPortsFcnArg(childS,childS);
30060
30061 /* outputs */
30062 {
30063 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
30064 calloc(1, sizeof(struct _ssPortOutputs));
30065 ss_VALIDATE_MEMORY(rts,outputPortInfo);
30066 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
30067 _ssSetNumOutputPorts(childS, 1);
30068
30069 /* port 0 */
30070 {
30071 _ssSetOutputPortNumDimensions(childS, 0, 1);
30072 ssSetOutputPortWidth(childS, 0, 1);
30073 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
30074 ssGetLocalBlockIO(rts))->GeneratedSFunction4_h));
30075 }
30076 }
30077
30078 /* path info */
30079 _ssSetModelName(childS, "LagFilter_sf");
30080 _ssSetPath(childS,
30081 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/ lag filter1/Generated S-Function4");
30082 if (ssGetRTModel(rts) == (NULL)) {
30083 _ssSetParentSS(childS, rts);
30084 _ssSetRootSS(childS, ssGetRootSS(rts));
30085 } else {
30086 ssSetRTModel(childS,ssGetRTModel(rts));
30087 _ssSetParentSS(childS, (NULL));
30088 _ssSetRootSS(childS, childS);
30089 }
30090
30091 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
30092
30093 /* work vectors */
30094 {
30095 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
30096 (4 * sizeof(struct _ssDWorkRecord));
30097 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
30098 calloc(4, sizeof(struct _ssDWorkAuxRecord));
30099 ss_VALIDATE_MEMORY(rts,dWorkRecord);
30100 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
30101 ssSetSFcnDWork(childS, dWorkRecord);
30102 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
30103 _ssSetNumDWork(childS, 4);
30104
30105 /* DWORK0 */
30106 ssSetDWorkWidth(childS, 0, 1);
30107 ssSetDWorkDataType(childS, 0,SS_SINGLE);
30108 ssSetDWorkComplexSignal(childS, 0, 0);
30109 ssSetDWorkUsedAsDState(childS, 0, 1);
30110 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 234))[0]);
30111
30112 /* DWORK1 */
30113 ssSetDWorkWidth(childS, 1, 1);
30114 ssSetDWorkDataType(childS, 1,SS_SINGLE);
30115 ssSetDWorkComplexSignal(childS, 1, 0);
30116 ssSetDWorkUsedAsDState(childS, 1, 1);
30117 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 235))[0]);
30118
30119 /* DWORK2 */
30120 ssSetDWorkWidth(childS, 2, 1);
30121 ssSetDWorkDataType(childS, 2,SS_INT8);
30122 ssSetDWorkComplexSignal(childS, 2, 0);
30123 ssSetDWorkUsedAsDState(childS, 2, 1);
30124 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 461))[0]);
30125
30126 /* DWORK3 */
30127 ssSetDWorkWidth(childS, 3, 1);
30128 ssSetDWorkDataType(childS, 3,SS_INT8);
30129 ssSetDWorkComplexSignal(childS, 3, 0);
30130 ssSetDWorkUsedAsDState(childS, 3, 1);
30131 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 462))[0]);
30132 }
30133
30134 (childS)->regDataType.arg1 = ((void *)(childS));
30135 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
30136 FcnSetErrorStatus);
30137 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
30138 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
30139 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
30140 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
30141
30142 /* registration */
30143#if defined(MATLAB_MEX_FILE)
30144
30145 {
30146 int_T i;
30147 mxArray *plhs[1];
30148 mxArray *prhs[4];
30149 double *pr;
30150 volatile int_T *intS = (int_T *)&childS;
30151 int_T addrlen = sizeof(SimStruct *);
30152 int_T m = addrlen/sizeof(int_T) + 1;
30153 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
30154 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
30155 pr = mxGetPr(prhs[1]);
30156 for (i = 0; i < m - 1; i++) {
30157 pr[i] = (double)intS[i];
30158 }
30159
30160 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
30161 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
30162 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
30163
30164 /* Reset port dimensions info functions because the S-function
30165 * and accelerator mex-files explicitly set their dimensions,
30166 * i.e., they are not dynamically sized. For this case, the
30167 * mex-file is responsible for the dimensions info memory
30168 * and Simulink should not free it. This is achieved by
30169 * setting the following two methods to NULL.
30170 */
30171 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
30172 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
30173
30174 /*
30175 * Setup function pointers and call mdlInitializeSizes via
30176 * simulink.c
30177 */
30178 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
30179 mxDestroyArray(plhs[0]);
30180 mxDestroyArray(prhs[0]);
30181 mxDestroyArray(prhs[1]);
30182 mxDestroyArray(prhs[2]);
30183 mxDestroyArray(prhs[3]);
30184 }
30185
30186#else
30187
30188 {
30189 LagFilter_sf(childS);
30190 sfcnInitializeSizes(childS);
30191 }
30192
30193#endif
30194
30195 sfcnInitializeSampleTimes(childS);
30196
30197 /* adjust sample time */
30198 ssSetSampleTime(childS, 0, 0.0);
30199 ssSetOffsetTime(childS, 0, 0.0);
30200 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
30201
30202 /* set compiled values of dynamic vector attributes */
30203 ssSetNumNonsampledZCs(childS, 0);
30204
30205 /* Update connectivity flags for each port */
30206 _ssSetInputPortConnected(childS, 0, 1);
30207 _ssSetInputPortConnected(childS, 1, 1);
30208 _ssSetInputPortConnected(childS, 2, 1);
30209 _ssSetInputPortConnected(childS, 3, 1);
30210 _ssSetInputPortConnected(childS, 4, 1);
30211 _ssSetInputPortConnected(childS, 5, 1);
30212 _ssSetOutputPortConnected(childS, 0, 1);
30213 _ssSetOutputPortBeingMerged(childS, 0, 0);
30214
30215 /* Update the BufferDstPort flags for each input port */
30216 _ssSetInputPortBufferDstPort(childS, 0, -1);
30217 _ssSetInputPortBufferDstPort(childS, 1, -1);
30218 _ssSetInputPortBufferDstPort(childS, 2, -1);
30219 _ssSetInputPortBufferDstPort(childS, 3, -1);
30220 _ssSetInputPortBufferDstPort(childS, 4, -1);
30221 _ssSetInputPortBufferDstPort(childS, 5, -1);
30222 }
30223
30224 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S77>/Generated S-Function1 (SaturationLimiter_sf) */
30225 {
30226 SimStruct *childS = ssGetSFunction(rts, 114);
30227
30228 /* timing info */
30229 time_T *sfcnPeriod;
30230 time_T *sfcnOffset;
30231 int_T *sfcnTsMap;
30232 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
30233 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
30234 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
30235 ss_VALIDATE_MEMORY(rts,sfcnOffset);
30236 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
30237 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
30238 (void) memset((void*)sfcnPeriod, 0,
30239 sizeof(time_T)*1);
30240 (void) memset((void*)sfcnOffset, 0,
30241 sizeof(time_T)*1);
30242 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
30243 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
30244 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
30245
30246 /* Set up the mdlInfo pointer */
30247# ifdef USE_RTMODEL
30248
30249 {
30250 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
30251 struct _ssBlkInfo2));
30252 ss_VALIDATE_MEMORY(rts,blkInfo2);
30253 ssSetBlkInfo2Ptr(childS, blkInfo2);
30254 }
30255
30256 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
30257
30258# else
30259
30260 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
30261
30262# endif /* USE_RTMODEL */
30263
30264 /* Allocate memory of model methods 2 */
30265 {
30266 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
30267 malloc(sizeof(struct _ssSFcnModelMethods2));
30268 ss_VALIDATE_MEMORY(rts,methods2);
30269 ssSetModelMethods2(childS, methods2);
30270 }
30271
30272 /* Allocate memory of model methods 3 */
30273 {
30274 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
30275 malloc(sizeof(struct _ssSFcnModelMethods3));
30276 ss_VALIDATE_MEMORY(rts,methods3);
30277 ssSetModelMethods3(childS, methods3);
30278 }
30279
30280 /* Allocate memory for states auxilliary information */
30281 {
30282 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
30283 (sizeof(struct _ssStatesInfo2));
30284 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
30285 malloc(sizeof(ssPeriodicStatesInfo));
30286 ss_VALIDATE_MEMORY(rts,statesInfo2);
30287 ssSetStatesInfo2(childS, statesInfo2);
30288 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
30289 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
30290 }
30291
30292 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
30293 RegNumInputPorts);
30294 ssSetRegNumInputPortsFcnArg(childS,childS);
30295
30296 /* inputs */
30297 {
30298 struct _ssPortInputs *inputPortInfo =
30299 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
30300 ss_VALIDATE_MEMORY(rts,inputPortInfo);
30301 _ssSetNumInputPorts(childS, 3);
30302 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
30303
30304 /* port 0 */
30305 {
30306 real32_T const **sfcnUPtrs = (real32_T const **)
30307 malloc(1 * sizeof(real32_T *));
30308 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30309 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
30310 ssGetLocalBlockIO(rts))->Sum2_b;
30311 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
30312 _ssSetInputPortNumDimensions(childS, 0, 1);
30313 ssSetInputPortWidth(childS, 0, 1);
30314 }
30315
30316 /* port 1 */
30317 {
30318 real32_T const **sfcnUPtrs = (real32_T const **)
30319 malloc(1 * sizeof(real32_T *));
30320 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30321 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
30322 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
30323 _ssSetInputPortNumDimensions(childS, 1, 1);
30324 ssSetInputPortWidth(childS, 1, 1);
30325 }
30326
30327 /* port 2 */
30328 {
30329 real32_T const **sfcnUPtrs = (real32_T const **)
30330 malloc(1 * sizeof(real32_T *));
30331 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30332 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled119;
30333 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
30334 _ssSetInputPortNumDimensions(childS, 2, 1);
30335 ssSetInputPortWidth(childS, 2, 1);
30336 }
30337 }
30338
30339 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
30340 RegNumOutputPorts);
30341 ssSetRegNumOutputPortsFcnArg(childS,childS);
30342
30343 /* outputs */
30344 {
30345 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
30346 calloc(1, sizeof(struct _ssPortOutputs));
30347 ss_VALIDATE_MEMORY(rts,outputPortInfo);
30348 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
30349 _ssSetNumOutputPorts(childS, 1);
30350
30351 /* port 0 */
30352 {
30353 _ssSetOutputPortNumDimensions(childS, 0, 1);
30354 ssSetOutputPortWidth(childS, 0, 1);
30355 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
30356 ssGetLocalBlockIO(rts))->GeneratedSFunction1_i));
30357 }
30358 }
30359
30360 /* path info */
30361 _ssSetModelName(childS, "SaturationLimiter_sf");
30362 _ssSetPath(childS,
30363 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/Saturation Limiter3/Generated S-Function1");
30364 if (ssGetRTModel(rts) == (NULL)) {
30365 _ssSetParentSS(childS, rts);
30366 _ssSetRootSS(childS, ssGetRootSS(rts));
30367 } else {
30368 ssSetRTModel(childS,ssGetRTModel(rts));
30369 _ssSetParentSS(childS, (NULL));
30370 _ssSetRootSS(childS, childS);
30371 }
30372
30373 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
30374 (childS)->regDataType.arg1 = ((void *)(childS));
30375 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
30376 FcnSetErrorStatus);
30377 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
30378 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
30379 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
30380 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
30381
30382 /* registration */
30383#if defined(MATLAB_MEX_FILE)
30384
30385 {
30386 int_T i;
30387 mxArray *plhs[1];
30388 mxArray *prhs[4];
30389 double *pr;
30390 volatile int_T *intS = (int_T *)&childS;
30391 int_T addrlen = sizeof(SimStruct *);
30392 int_T m = addrlen/sizeof(int_T) + 1;
30393 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
30394 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
30395 pr = mxGetPr(prhs[1]);
30396 for (i = 0; i < m - 1; i++) {
30397 pr[i] = (double)intS[i];
30398 }
30399
30400 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
30401 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
30402 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
30403
30404 /* Reset port dimensions info functions because the S-function
30405 * and accelerator mex-files explicitly set their dimensions,
30406 * i.e., they are not dynamically sized. For this case, the
30407 * mex-file is responsible for the dimensions info memory
30408 * and Simulink should not free it. This is achieved by
30409 * setting the following two methods to NULL.
30410 */
30411 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
30412 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
30413
30414 /*
30415 * Setup function pointers and call mdlInitializeSizes via
30416 * simulink.c
30417 */
30418 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
30419 mxDestroyArray(plhs[0]);
30420 mxDestroyArray(prhs[0]);
30421 mxDestroyArray(prhs[1]);
30422 mxDestroyArray(prhs[2]);
30423 mxDestroyArray(prhs[3]);
30424 }
30425
30426#else
30427
30428 {
30429 SaturationLimiter_sf(childS);
30430 sfcnInitializeSizes(childS);
30431 }
30432
30433#endif
30434
30435 sfcnInitializeSampleTimes(childS);
30436
30437 /* adjust sample time */
30438 ssSetSampleTime(childS, 0, 0.0);
30439 ssSetOffsetTime(childS, 0, 0.0);
30440 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
30441
30442 /* set compiled values of dynamic vector attributes */
30443 ssSetNumNonsampledZCs(childS, 0);
30444
30445 /* Update connectivity flags for each port */
30446 _ssSetInputPortConnected(childS, 0, 1);
30447 _ssSetInputPortConnected(childS, 1, 1);
30448 _ssSetInputPortConnected(childS, 2, 1);
30449 _ssSetOutputPortConnected(childS, 0, 1);
30450 _ssSetOutputPortBeingMerged(childS, 0, 0);
30451
30452 /* Update the BufferDstPort flags for each input port */
30453 _ssSetInputPortBufferDstPort(childS, 0, -1);
30454 _ssSetInputPortBufferDstPort(childS, 1, -1);
30455 _ssSetInputPortBufferDstPort(childS, 2, -1);
30456 }
30457
30458 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S79>/Generated S-Function (Gain_sf) */
30459 {
30460 SimStruct *childS = ssGetSFunction(rts, 115);
30461
30462 /* timing info */
30463 time_T *sfcnPeriod;
30464 time_T *sfcnOffset;
30465 int_T *sfcnTsMap;
30466 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
30467 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
30468 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
30469 ss_VALIDATE_MEMORY(rts,sfcnOffset);
30470 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
30471 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
30472 (void) memset((void*)sfcnPeriod, 0,
30473 sizeof(time_T)*1);
30474 (void) memset((void*)sfcnOffset, 0,
30475 sizeof(time_T)*1);
30476 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
30477 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
30478 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
30479
30480 /* Set up the mdlInfo pointer */
30481# ifdef USE_RTMODEL
30482
30483 {
30484 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
30485 struct _ssBlkInfo2));
30486 ss_VALIDATE_MEMORY(rts,blkInfo2);
30487 ssSetBlkInfo2Ptr(childS, blkInfo2);
30488 }
30489
30490 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
30491
30492# else
30493
30494 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
30495
30496# endif /* USE_RTMODEL */
30497
30498 /* Allocate memory of model methods 2 */
30499 {
30500 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
30501 malloc(sizeof(struct _ssSFcnModelMethods2));
30502 ss_VALIDATE_MEMORY(rts,methods2);
30503 ssSetModelMethods2(childS, methods2);
30504 }
30505
30506 /* Allocate memory of model methods 3 */
30507 {
30508 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
30509 malloc(sizeof(struct _ssSFcnModelMethods3));
30510 ss_VALIDATE_MEMORY(rts,methods3);
30511 ssSetModelMethods3(childS, methods3);
30512 }
30513
30514 /* Allocate memory for states auxilliary information */
30515 {
30516 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
30517 (sizeof(struct _ssStatesInfo2));
30518 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
30519 malloc(sizeof(ssPeriodicStatesInfo));
30520 ss_VALIDATE_MEMORY(rts,statesInfo2);
30521 ssSetStatesInfo2(childS, statesInfo2);
30522 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
30523 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
30524 }
30525
30526 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
30527 RegNumInputPorts);
30528 ssSetRegNumInputPortsFcnArg(childS,childS);
30529
30530 /* inputs */
30531 {
30532 struct _ssPortInputs *inputPortInfo =
30533 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
30534 ss_VALIDATE_MEMORY(rts,inputPortInfo);
30535 _ssSetNumInputPorts(childS, 2);
30536 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
30537
30538 /* port 0 */
30539 {
30540 real32_T const **sfcnUPtrs = (real32_T const **)
30541 malloc(1 * sizeof(real32_T *));
30542 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30543 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
30544 ssGetLocalBlockIO(rts))->GeneratedSFunction1_i;
30545 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
30546 _ssSetInputPortNumDimensions(childS, 0, 1);
30547 ssSetInputPortWidth(childS, 0, 1);
30548 }
30549
30550 /* port 1 */
30551 {
30552 real32_T const **sfcnUPtrs = (real32_T const **)
30553 malloc(1 * sizeof(real32_T *));
30554 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30555 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
30556 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
30557 _ssSetInputPortNumDimensions(childS, 1, 1);
30558 ssSetInputPortWidth(childS, 1, 1);
30559 }
30560 }
30561
30562 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
30563 RegNumOutputPorts);
30564 ssSetRegNumOutputPortsFcnArg(childS,childS);
30565
30566 /* outputs */
30567 {
30568 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
30569 calloc(1, sizeof(struct _ssPortOutputs));
30570 ss_VALIDATE_MEMORY(rts,outputPortInfo);
30571 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
30572 _ssSetNumOutputPorts(childS, 1);
30573
30574 /* port 0 */
30575 {
30576 _ssSetOutputPortNumDimensions(childS, 0, 1);
30577 ssSetOutputPortWidth(childS, 0, 1);
30578 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
30579 ssGetLocalBlockIO(rts))->Saturation2_p));
30580 }
30581 }
30582
30583 /* path info */
30584 _ssSetModelName(childS, "Gain_sf");
30585 _ssSetPath(childS,
30586 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/gain3/Generated S-Function");
30587 if (ssGetRTModel(rts) == (NULL)) {
30588 _ssSetParentSS(childS, rts);
30589 _ssSetRootSS(childS, ssGetRootSS(rts));
30590 } else {
30591 ssSetRTModel(childS,ssGetRTModel(rts));
30592 _ssSetParentSS(childS, (NULL));
30593 _ssSetRootSS(childS, childS);
30594 }
30595
30596 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
30597 (childS)->regDataType.arg1 = ((void *)(childS));
30598 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
30599 FcnSetErrorStatus);
30600 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
30601 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
30602 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
30603 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
30604
30605 /* registration */
30606#if defined(MATLAB_MEX_FILE)
30607
30608 {
30609 int_T i;
30610 mxArray *plhs[1];
30611 mxArray *prhs[4];
30612 double *pr;
30613 volatile int_T *intS = (int_T *)&childS;
30614 int_T addrlen = sizeof(SimStruct *);
30615 int_T m = addrlen/sizeof(int_T) + 1;
30616 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
30617 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
30618 pr = mxGetPr(prhs[1]);
30619 for (i = 0; i < m - 1; i++) {
30620 pr[i] = (double)intS[i];
30621 }
30622
30623 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
30624 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
30625 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
30626
30627 /* Reset port dimensions info functions because the S-function
30628 * and accelerator mex-files explicitly set their dimensions,
30629 * i.e., they are not dynamically sized. For this case, the
30630 * mex-file is responsible for the dimensions info memory
30631 * and Simulink should not free it. This is achieved by
30632 * setting the following two methods to NULL.
30633 */
30634 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
30635 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
30636
30637 /*
30638 * Setup function pointers and call mdlInitializeSizes via
30639 * simulink.c
30640 */
30641 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
30642 mxDestroyArray(plhs[0]);
30643 mxDestroyArray(prhs[0]);
30644 mxDestroyArray(prhs[1]);
30645 mxDestroyArray(prhs[2]);
30646 mxDestroyArray(prhs[3]);
30647 }
30648
30649#else
30650
30651 {
30652 Gain_sf(childS);
30653 sfcnInitializeSizes(childS);
30654 }
30655
30656#endif
30657
30658 sfcnInitializeSampleTimes(childS);
30659
30660 /* adjust sample time */
30661 ssSetSampleTime(childS, 0, 0.0);
30662 ssSetOffsetTime(childS, 0, 0.0);
30663 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
30664
30665 /* set compiled values of dynamic vector attributes */
30666 ssSetNumNonsampledZCs(childS, 0);
30667
30668 /* Update connectivity flags for each port */
30669 _ssSetInputPortConnected(childS, 0, 1);
30670 _ssSetInputPortConnected(childS, 1, 1);
30671 _ssSetOutputPortConnected(childS, 0, 1);
30672 _ssSetOutputPortBeingMerged(childS, 0, 0);
30673
30674 /* Update the BufferDstPort flags for each input port */
30675 _ssSetInputPortBufferDstPort(childS, 0, -1);
30676 _ssSetInputPortBufferDstPort(childS, 1, -1);
30677 }
30678
30679 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S72>/Generated S-Function6 (Res180_sf) */
30680 {
30681 SimStruct *childS = ssGetSFunction(rts, 116);
30682
30683 /* timing info */
30684 time_T *sfcnPeriod;
30685 time_T *sfcnOffset;
30686 int_T *sfcnTsMap;
30687 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
30688 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
30689 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
30690 ss_VALIDATE_MEMORY(rts,sfcnOffset);
30691 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
30692 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
30693 (void) memset((void*)sfcnPeriod, 0,
30694 sizeof(time_T)*1);
30695 (void) memset((void*)sfcnOffset, 0,
30696 sizeof(time_T)*1);
30697 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
30698 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
30699 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
30700
30701 /* Set up the mdlInfo pointer */
30702# ifdef USE_RTMODEL
30703
30704 {
30705 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
30706 struct _ssBlkInfo2));
30707 ss_VALIDATE_MEMORY(rts,blkInfo2);
30708 ssSetBlkInfo2Ptr(childS, blkInfo2);
30709 }
30710
30711 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
30712
30713# else
30714
30715 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
30716
30717# endif /* USE_RTMODEL */
30718
30719 /* Allocate memory of model methods 2 */
30720 {
30721 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
30722 malloc(sizeof(struct _ssSFcnModelMethods2));
30723 ss_VALIDATE_MEMORY(rts,methods2);
30724 ssSetModelMethods2(childS, methods2);
30725 }
30726
30727 /* Allocate memory of model methods 3 */
30728 {
30729 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
30730 malloc(sizeof(struct _ssSFcnModelMethods3));
30731 ss_VALIDATE_MEMORY(rts,methods3);
30732 ssSetModelMethods3(childS, methods3);
30733 }
30734
30735 /* Allocate memory for states auxilliary information */
30736 {
30737 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
30738 (sizeof(struct _ssStatesInfo2));
30739 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
30740 malloc(sizeof(ssPeriodicStatesInfo));
30741 ss_VALIDATE_MEMORY(rts,statesInfo2);
30742 ssSetStatesInfo2(childS, statesInfo2);
30743 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
30744 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
30745 }
30746
30747 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
30748 RegNumInputPorts);
30749 ssSetRegNumInputPortsFcnArg(childS,childS);
30750
30751 /* inputs */
30752 {
30753 struct _ssPortInputs *inputPortInfo =
30754 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
30755 ss_VALIDATE_MEMORY(rts,inputPortInfo);
30756 _ssSetNumInputPorts(childS, 1);
30757 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
30758
30759 /* port 0 */
30760 {
30761 real32_T const **sfcnUPtrs = (real32_T const **)
30762 malloc(1 * sizeof(real32_T *));
30763 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30764 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
30765 ssGetLocalBlockIO(rts))->Sum3_ca;
30766 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
30767 _ssSetInputPortNumDimensions(childS, 0, 1);
30768 ssSetInputPortWidth(childS, 0, 1);
30769 }
30770 }
30771
30772 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
30773 RegNumOutputPorts);
30774 ssSetRegNumOutputPortsFcnArg(childS,childS);
30775
30776 /* outputs */
30777 {
30778 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
30779 calloc(1, sizeof(struct _ssPortOutputs));
30780 ss_VALIDATE_MEMORY(rts,outputPortInfo);
30781 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
30782 _ssSetNumOutputPorts(childS, 1);
30783
30784 /* port 0 */
30785 {
30786 _ssSetOutputPortNumDimensions(childS, 0, 1);
30787 ssSetOutputPortWidth(childS, 0, 1);
30788 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
30789 ssGetLocalBlockIO(rts))->GeneratedSFunction6_j));
30790 }
30791 }
30792
30793 /* path info */
30794 _ssSetModelName(childS, "Res180_sf");
30795 _ssSetPath(childS,
30796 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/Generated S-Function6");
30797 if (ssGetRTModel(rts) == (NULL)) {
30798 _ssSetParentSS(childS, rts);
30799 _ssSetRootSS(childS, ssGetRootSS(rts));
30800 } else {
30801 ssSetRTModel(childS,ssGetRTModel(rts));
30802 _ssSetParentSS(childS, (NULL));
30803 _ssSetRootSS(childS, childS);
30804 }
30805
30806 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
30807 (childS)->regDataType.arg1 = ((void *)(childS));
30808 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
30809 FcnSetErrorStatus);
30810 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
30811 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
30812 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
30813 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
30814
30815 /* registration */
30816#if defined(MATLAB_MEX_FILE)
30817
30818 {
30819 int_T i;
30820 mxArray *plhs[1];
30821 mxArray *prhs[4];
30822 double *pr;
30823 volatile int_T *intS = (int_T *)&childS;
30824 int_T addrlen = sizeof(SimStruct *);
30825 int_T m = addrlen/sizeof(int_T) + 1;
30826 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
30827 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
30828 pr = mxGetPr(prhs[1]);
30829 for (i = 0; i < m - 1; i++) {
30830 pr[i] = (double)intS[i];
30831 }
30832
30833 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
30834 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
30835 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
30836
30837 /* Reset port dimensions info functions because the S-function
30838 * and accelerator mex-files explicitly set their dimensions,
30839 * i.e., they are not dynamically sized. For this case, the
30840 * mex-file is responsible for the dimensions info memory
30841 * and Simulink should not free it. This is achieved by
30842 * setting the following two methods to NULL.
30843 */
30844 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
30845 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
30846
30847 /*
30848 * Setup function pointers and call mdlInitializeSizes via
30849 * simulink.c
30850 */
30851 mexCallMATLAB(1, plhs, 4, prhs, "Res180_sf");
30852 mxDestroyArray(plhs[0]);
30853 mxDestroyArray(prhs[0]);
30854 mxDestroyArray(prhs[1]);
30855 mxDestroyArray(prhs[2]);
30856 mxDestroyArray(prhs[3]);
30857 }
30858
30859#else
30860
30861 {
30862 Res180_sf(childS);
30863 sfcnInitializeSizes(childS);
30864 }
30865
30866#endif
30867
30868 sfcnInitializeSampleTimes(childS);
30869
30870 /* adjust sample time */
30871 ssSetSampleTime(childS, 0, 0.0);
30872 ssSetOffsetTime(childS, 0, 0.0);
30873 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
30874
30875 /* set compiled values of dynamic vector attributes */
30876 ssSetNumNonsampledZCs(childS, 0);
30877
30878 /* Update connectivity flags for each port */
30879 _ssSetInputPortConnected(childS, 0, 1);
30880 _ssSetOutputPortConnected(childS, 0, 1);
30881 _ssSetOutputPortBeingMerged(childS, 0, 0);
30882
30883 /* Update the BufferDstPort flags for each input port */
30884 _ssSetInputPortBufferDstPort(childS, 0, -1);
30885 }
30886
30887 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S76>/Generated S-Function1 (SaturationLimiter_sf) */
30888 {
30889 SimStruct *childS = ssGetSFunction(rts, 117);
30890
30891 /* timing info */
30892 time_T *sfcnPeriod;
30893 time_T *sfcnOffset;
30894 int_T *sfcnTsMap;
30895 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
30896 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
30897 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
30898 ss_VALIDATE_MEMORY(rts,sfcnOffset);
30899 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
30900 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
30901 (void) memset((void*)sfcnPeriod, 0,
30902 sizeof(time_T)*1);
30903 (void) memset((void*)sfcnOffset, 0,
30904 sizeof(time_T)*1);
30905 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
30906 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
30907 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
30908
30909 /* Set up the mdlInfo pointer */
30910# ifdef USE_RTMODEL
30911
30912 {
30913 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
30914 struct _ssBlkInfo2));
30915 ss_VALIDATE_MEMORY(rts,blkInfo2);
30916 ssSetBlkInfo2Ptr(childS, blkInfo2);
30917 }
30918
30919 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
30920
30921# else
30922
30923 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
30924
30925# endif /* USE_RTMODEL */
30926
30927 /* Allocate memory of model methods 2 */
30928 {
30929 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
30930 malloc(sizeof(struct _ssSFcnModelMethods2));
30931 ss_VALIDATE_MEMORY(rts,methods2);
30932 ssSetModelMethods2(childS, methods2);
30933 }
30934
30935 /* Allocate memory of model methods 3 */
30936 {
30937 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
30938 malloc(sizeof(struct _ssSFcnModelMethods3));
30939 ss_VALIDATE_MEMORY(rts,methods3);
30940 ssSetModelMethods3(childS, methods3);
30941 }
30942
30943 /* Allocate memory for states auxilliary information */
30944 {
30945 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
30946 (sizeof(struct _ssStatesInfo2));
30947 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
30948 malloc(sizeof(ssPeriodicStatesInfo));
30949 ss_VALIDATE_MEMORY(rts,statesInfo2);
30950 ssSetStatesInfo2(childS, statesInfo2);
30951 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
30952 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
30953 }
30954
30955 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
30956 RegNumInputPorts);
30957 ssSetRegNumInputPortsFcnArg(childS,childS);
30958
30959 /* inputs */
30960 {
30961 struct _ssPortInputs *inputPortInfo =
30962 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
30963 ss_VALIDATE_MEMORY(rts,inputPortInfo);
30964 _ssSetNumInputPorts(childS, 3);
30965 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
30966
30967 /* port 0 */
30968 {
30969 real32_T const **sfcnUPtrs = (real32_T const **)
30970 malloc(1 * sizeof(real32_T *));
30971 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30972 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
30973 ssGetLocalBlockIO(rts))->GeneratedSFunction6_j;
30974 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
30975 _ssSetInputPortNumDimensions(childS, 0, 1);
30976 ssSetInputPortWidth(childS, 0, 1);
30977 }
30978
30979 /* port 1 */
30980 {
30981 real32_T const **sfcnUPtrs = (real32_T const **)
30982 malloc(1 * sizeof(real32_T *));
30983 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30984 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled120;
30985 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
30986 _ssSetInputPortNumDimensions(childS, 1, 1);
30987 ssSetInputPortWidth(childS, 1, 1);
30988 }
30989
30990 /* port 2 */
30991 {
30992 real32_T const **sfcnUPtrs = (real32_T const **)
30993 malloc(1 * sizeof(real32_T *));
30994 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
30995 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled121;
30996 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
30997 _ssSetInputPortNumDimensions(childS, 2, 1);
30998 ssSetInputPortWidth(childS, 2, 1);
30999 }
31000 }
31001
31002 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
31003 RegNumOutputPorts);
31004 ssSetRegNumOutputPortsFcnArg(childS,childS);
31005
31006 /* outputs */
31007 {
31008 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
31009 calloc(1, sizeof(struct _ssPortOutputs));
31010 ss_VALIDATE_MEMORY(rts,outputPortInfo);
31011 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
31012 _ssSetNumOutputPorts(childS, 1);
31013
31014 /* port 0 */
31015 {
31016 _ssSetOutputPortNumDimensions(childS, 0, 1);
31017 ssSetOutputPortWidth(childS, 0, 1);
31018 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
31019 ssGetLocalBlockIO(rts))->GeneratedSFunction1_k));
31020 }
31021 }
31022
31023 /* path info */
31024 _ssSetModelName(childS, "SaturationLimiter_sf");
31025 _ssSetPath(childS,
31026 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/Saturation Limiter1/Generated S-Function1");
31027 if (ssGetRTModel(rts) == (NULL)) {
31028 _ssSetParentSS(childS, rts);
31029 _ssSetRootSS(childS, ssGetRootSS(rts));
31030 } else {
31031 ssSetRTModel(childS,ssGetRTModel(rts));
31032 _ssSetParentSS(childS, (NULL));
31033 _ssSetRootSS(childS, childS);
31034 }
31035
31036 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
31037 (childS)->regDataType.arg1 = ((void *)(childS));
31038 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
31039 FcnSetErrorStatus);
31040 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
31041 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
31042 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
31043 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
31044
31045 /* registration */
31046#if defined(MATLAB_MEX_FILE)
31047
31048 {
31049 int_T i;
31050 mxArray *plhs[1];
31051 mxArray *prhs[4];
31052 double *pr;
31053 volatile int_T *intS = (int_T *)&childS;
31054 int_T addrlen = sizeof(SimStruct *);
31055 int_T m = addrlen/sizeof(int_T) + 1;
31056 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
31057 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
31058 pr = mxGetPr(prhs[1]);
31059 for (i = 0; i < m - 1; i++) {
31060 pr[i] = (double)intS[i];
31061 }
31062
31063 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
31064 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
31065 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
31066
31067 /* Reset port dimensions info functions because the S-function
31068 * and accelerator mex-files explicitly set their dimensions,
31069 * i.e., they are not dynamically sized. For this case, the
31070 * mex-file is responsible for the dimensions info memory
31071 * and Simulink should not free it. This is achieved by
31072 * setting the following two methods to NULL.
31073 */
31074 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
31075 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
31076
31077 /*
31078 * Setup function pointers and call mdlInitializeSizes via
31079 * simulink.c
31080 */
31081 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
31082 mxDestroyArray(plhs[0]);
31083 mxDestroyArray(prhs[0]);
31084 mxDestroyArray(prhs[1]);
31085 mxDestroyArray(prhs[2]);
31086 mxDestroyArray(prhs[3]);
31087 }
31088
31089#else
31090
31091 {
31092 SaturationLimiter_sf(childS);
31093 sfcnInitializeSizes(childS);
31094 }
31095
31096#endif
31097
31098 sfcnInitializeSampleTimes(childS);
31099
31100 /* adjust sample time */
31101 ssSetSampleTime(childS, 0, 0.0);
31102 ssSetOffsetTime(childS, 0, 0.0);
31103 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
31104
31105 /* set compiled values of dynamic vector attributes */
31106 ssSetNumNonsampledZCs(childS, 0);
31107
31108 /* Update connectivity flags for each port */
31109 _ssSetInputPortConnected(childS, 0, 1);
31110 _ssSetInputPortConnected(childS, 1, 1);
31111 _ssSetInputPortConnected(childS, 2, 1);
31112 _ssSetOutputPortConnected(childS, 0, 1);
31113 _ssSetOutputPortBeingMerged(childS, 0, 0);
31114
31115 /* Update the BufferDstPort flags for each input port */
31116 _ssSetInputPortBufferDstPort(childS, 0, -1);
31117 _ssSetInputPortBufferDstPort(childS, 1, -1);
31118 _ssSetInputPortBufferDstPort(childS, 2, -1);
31119 }
31120
31121 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S78>/Generated S-Function (Gain_sf) */
31122 {
31123 SimStruct *childS = ssGetSFunction(rts, 118);
31124
31125 /* timing info */
31126 time_T *sfcnPeriod;
31127 time_T *sfcnOffset;
31128 int_T *sfcnTsMap;
31129 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
31130 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
31131 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
31132 ss_VALIDATE_MEMORY(rts,sfcnOffset);
31133 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
31134 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
31135 (void) memset((void*)sfcnPeriod, 0,
31136 sizeof(time_T)*1);
31137 (void) memset((void*)sfcnOffset, 0,
31138 sizeof(time_T)*1);
31139 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
31140 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
31141 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
31142
31143 /* Set up the mdlInfo pointer */
31144# ifdef USE_RTMODEL
31145
31146 {
31147 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
31148 struct _ssBlkInfo2));
31149 ss_VALIDATE_MEMORY(rts,blkInfo2);
31150 ssSetBlkInfo2Ptr(childS, blkInfo2);
31151 }
31152
31153 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
31154
31155# else
31156
31157 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
31158
31159# endif /* USE_RTMODEL */
31160
31161 /* Allocate memory of model methods 2 */
31162 {
31163 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
31164 malloc(sizeof(struct _ssSFcnModelMethods2));
31165 ss_VALIDATE_MEMORY(rts,methods2);
31166 ssSetModelMethods2(childS, methods2);
31167 }
31168
31169 /* Allocate memory of model methods 3 */
31170 {
31171 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
31172 malloc(sizeof(struct _ssSFcnModelMethods3));
31173 ss_VALIDATE_MEMORY(rts,methods3);
31174 ssSetModelMethods3(childS, methods3);
31175 }
31176
31177 /* Allocate memory for states auxilliary information */
31178 {
31179 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
31180 (sizeof(struct _ssStatesInfo2));
31181 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
31182 malloc(sizeof(ssPeriodicStatesInfo));
31183 ss_VALIDATE_MEMORY(rts,statesInfo2);
31184 ssSetStatesInfo2(childS, statesInfo2);
31185 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
31186 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
31187 }
31188
31189 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
31190 RegNumInputPorts);
31191 ssSetRegNumInputPortsFcnArg(childS,childS);
31192
31193 /* inputs */
31194 {
31195 struct _ssPortInputs *inputPortInfo =
31196 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
31197 ss_VALIDATE_MEMORY(rts,inputPortInfo);
31198 _ssSetNumInputPorts(childS, 2);
31199 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
31200
31201 /* port 0 */
31202 {
31203 real32_T const **sfcnUPtrs = (real32_T const **)
31204 malloc(1 * sizeof(real32_T *));
31205 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31206 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
31207 ssGetLocalBlockIO(rts))->GeneratedSFunction1_k;
31208 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
31209 _ssSetInputPortNumDimensions(childS, 0, 1);
31210 ssSetInputPortWidth(childS, 0, 1);
31211 }
31212
31213 /* port 1 */
31214 {
31215 real32_T const **sfcnUPtrs = (real32_T const **)
31216 malloc(1 * sizeof(real32_T *));
31217 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31218 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
31219 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
31220 _ssSetInputPortNumDimensions(childS, 1, 1);
31221 ssSetInputPortWidth(childS, 1, 1);
31222 }
31223 }
31224
31225 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
31226 RegNumOutputPorts);
31227 ssSetRegNumOutputPortsFcnArg(childS,childS);
31228
31229 /* outputs */
31230 {
31231 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
31232 calloc(1, sizeof(struct _ssPortOutputs));
31233 ss_VALIDATE_MEMORY(rts,outputPortInfo);
31234 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
31235 _ssSetNumOutputPorts(childS, 1);
31236
31237 /* port 0 */
31238 {
31239 _ssSetOutputPortNumDimensions(childS, 0, 1);
31240 ssSetOutputPortWidth(childS, 0, 1);
31241 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
31242 ssGetLocalBlockIO(rts))->GeneratedSFunction_cq));
31243 }
31244 }
31245
31246 /* path info */
31247 _ssSetModelName(childS, "Gain_sf");
31248 _ssSetPath(childS,
31249 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/gain2/Generated S-Function");
31250 if (ssGetRTModel(rts) == (NULL)) {
31251 _ssSetParentSS(childS, rts);
31252 _ssSetRootSS(childS, ssGetRootSS(rts));
31253 } else {
31254 ssSetRTModel(childS,ssGetRTModel(rts));
31255 _ssSetParentSS(childS, (NULL));
31256 _ssSetRootSS(childS, childS);
31257 }
31258
31259 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
31260 (childS)->regDataType.arg1 = ((void *)(childS));
31261 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
31262 FcnSetErrorStatus);
31263 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
31264 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
31265 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
31266 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
31267
31268 /* registration */
31269#if defined(MATLAB_MEX_FILE)
31270
31271 {
31272 int_T i;
31273 mxArray *plhs[1];
31274 mxArray *prhs[4];
31275 double *pr;
31276 volatile int_T *intS = (int_T *)&childS;
31277 int_T addrlen = sizeof(SimStruct *);
31278 int_T m = addrlen/sizeof(int_T) + 1;
31279 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
31280 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
31281 pr = mxGetPr(prhs[1]);
31282 for (i = 0; i < m - 1; i++) {
31283 pr[i] = (double)intS[i];
31284 }
31285
31286 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
31287 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
31288 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
31289
31290 /* Reset port dimensions info functions because the S-function
31291 * and accelerator mex-files explicitly set their dimensions,
31292 * i.e., they are not dynamically sized. For this case, the
31293 * mex-file is responsible for the dimensions info memory
31294 * and Simulink should not free it. This is achieved by
31295 * setting the following two methods to NULL.
31296 */
31297 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
31298 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
31299
31300 /*
31301 * Setup function pointers and call mdlInitializeSizes via
31302 * simulink.c
31303 */
31304 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
31305 mxDestroyArray(plhs[0]);
31306 mxDestroyArray(prhs[0]);
31307 mxDestroyArray(prhs[1]);
31308 mxDestroyArray(prhs[2]);
31309 mxDestroyArray(prhs[3]);
31310 }
31311
31312#else
31313
31314 {
31315 Gain_sf(childS);
31316 sfcnInitializeSizes(childS);
31317 }
31318
31319#endif
31320
31321 sfcnInitializeSampleTimes(childS);
31322
31323 /* adjust sample time */
31324 ssSetSampleTime(childS, 0, 0.0);
31325 ssSetOffsetTime(childS, 0, 0.0);
31326 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
31327
31328 /* set compiled values of dynamic vector attributes */
31329 ssSetNumNonsampledZCs(childS, 0);
31330
31331 /* Update connectivity flags for each port */
31332 _ssSetInputPortConnected(childS, 0, 1);
31333 _ssSetInputPortConnected(childS, 1, 1);
31334 _ssSetOutputPortConnected(childS, 0, 1);
31335 _ssSetOutputPortBeingMerged(childS, 0, 0);
31336
31337 /* Update the BufferDstPort flags for each input port */
31338 _ssSetInputPortBufferDstPort(childS, 0, -1);
31339 _ssSetInputPortBufferDstPort(childS, 1, -1);
31340 }
31341
31342 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S75>/Generated S-Function2 (LeadLagFilter_sf) */
31343 {
31344 SimStruct *childS = ssGetSFunction(rts, 119);
31345
31346 /* timing info */
31347 time_T *sfcnPeriod;
31348 time_T *sfcnOffset;
31349 int_T *sfcnTsMap;
31350 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
31351 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
31352 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
31353 ss_VALIDATE_MEMORY(rts,sfcnOffset);
31354 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
31355 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
31356 (void) memset((void*)sfcnPeriod, 0,
31357 sizeof(time_T)*1);
31358 (void) memset((void*)sfcnOffset, 0,
31359 sizeof(time_T)*1);
31360 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
31361 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
31362 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
31363
31364 /* Set up the mdlInfo pointer */
31365# ifdef USE_RTMODEL
31366
31367 {
31368 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
31369 struct _ssBlkInfo2));
31370 ss_VALIDATE_MEMORY(rts,blkInfo2);
31371 ssSetBlkInfo2Ptr(childS, blkInfo2);
31372 }
31373
31374 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
31375
31376# else
31377
31378 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
31379
31380# endif /* USE_RTMODEL */
31381
31382 /* Allocate memory of model methods 2 */
31383 {
31384 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
31385 malloc(sizeof(struct _ssSFcnModelMethods2));
31386 ss_VALIDATE_MEMORY(rts,methods2);
31387 ssSetModelMethods2(childS, methods2);
31388 }
31389
31390 /* Allocate memory of model methods 3 */
31391 {
31392 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
31393 malloc(sizeof(struct _ssSFcnModelMethods3));
31394 ss_VALIDATE_MEMORY(rts,methods3);
31395 ssSetModelMethods3(childS, methods3);
31396 }
31397
31398 /* Allocate memory for states auxilliary information */
31399 {
31400 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
31401 (sizeof(struct _ssStatesInfo2));
31402 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
31403 malloc(sizeof(ssPeriodicStatesInfo));
31404 ss_VALIDATE_MEMORY(rts,statesInfo2);
31405 ssSetStatesInfo2(childS, statesInfo2);
31406 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
31407 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
31408 }
31409
31410 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
31411 RegNumInputPorts);
31412 ssSetRegNumInputPortsFcnArg(childS,childS);
31413
31414 /* inputs */
31415 {
31416 struct _ssPortInputs *inputPortInfo =
31417 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
31418 ss_VALIDATE_MEMORY(rts,inputPortInfo);
31419 _ssSetNumInputPorts(childS, 7);
31420 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
31421
31422 /* port 0 */
31423 {
31424 real32_T const **sfcnUPtrs = (real32_T const **)
31425 malloc(1 * sizeof(real32_T *));
31426 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31427 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
31428 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
31429 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
31430 _ssSetInputPortNumDimensions(childS, 0, 1);
31431 ssSetInputPortWidth(childS, 0, 1);
31432 }
31433
31434 /* port 1 */
31435 {
31436 int8_T const **sfcnUPtrs = (int8_T const **)
31437 malloc(1 * sizeof(int8_T *));
31438 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31439 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
31440 ssGetLocalBlockIO(rts))->DataTypeConversion1_jy;
31441 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
31442 _ssSetInputPortNumDimensions(childS, 1, 1);
31443 ssSetInputPortWidth(childS, 1, 1);
31444 }
31445
31446 /* port 2 */
31447 {
31448 real32_T const **sfcnUPtrs = (real32_T const **)
31449 malloc(1 * sizeof(real32_T *));
31450 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31451 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
31452 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
31453 _ssSetInputPortNumDimensions(childS, 2, 1);
31454 ssSetInputPortWidth(childS, 2, 1);
31455 }
31456
31457 /* port 3 */
31458 {
31459 real32_T const **sfcnUPtrs = (real32_T const **)
31460 malloc(1 * sizeof(real32_T *));
31461 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31462 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
31463 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
31464 _ssSetInputPortNumDimensions(childS, 3, 1);
31465 ssSetInputPortWidth(childS, 3, 1);
31466 }
31467
31468 /* port 4 */
31469 {
31470 real32_T const **sfcnUPtrs = (real32_T const **)
31471 malloc(1 * sizeof(real32_T *));
31472 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31473 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
31474 ssGetLocalBlockIO(rts))->Switch_fz;
31475 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
31476 _ssSetInputPortNumDimensions(childS, 4, 1);
31477 ssSetInputPortWidth(childS, 4, 1);
31478 }
31479
31480 /* port 5 */
31481 {
31482 real32_T const **sfcnUPtrs = (real32_T const **)
31483 malloc(1 * sizeof(real32_T *));
31484 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31485 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
31486 ssGetLocalBlockIO(rts))->Switch_fz;
31487 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
31488 _ssSetInputPortNumDimensions(childS, 5, 1);
31489 ssSetInputPortWidth(childS, 5, 1);
31490 }
31491
31492 /* port 6 */
31493 {
31494 real32_T const **sfcnUPtrs = (real32_T const **)
31495 malloc(1 * sizeof(real32_T *));
31496 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31497 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
31498 ssGetLocalBlockIO(rts))->GeneratedSFunction_cq;
31499 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
31500 _ssSetInputPortNumDimensions(childS, 6, 1);
31501 ssSetInputPortWidth(childS, 6, 1);
31502 }
31503 }
31504
31505 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
31506 RegNumOutputPorts);
31507 ssSetRegNumOutputPortsFcnArg(childS,childS);
31508
31509 /* outputs */
31510 {
31511 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
31512 calloc(1, sizeof(struct _ssPortOutputs));
31513 ss_VALIDATE_MEMORY(rts,outputPortInfo);
31514 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
31515 _ssSetNumOutputPorts(childS, 1);
31516
31517 /* port 0 */
31518 {
31519 _ssSetOutputPortNumDimensions(childS, 0, 1);
31520 ssSetOutputPortWidth(childS, 0, 1);
31521 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
31522 ssGetLocalBlockIO(rts))->GeneratedSFunction2_m5));
31523 }
31524 }
31525
31526 /* path info */
31527 _ssSetModelName(childS, "LeadLagFilter_sf");
31528 _ssSetPath(childS,
31529 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/Lead lag1/Generated S-Function2");
31530 if (ssGetRTModel(rts) == (NULL)) {
31531 _ssSetParentSS(childS, rts);
31532 _ssSetRootSS(childS, ssGetRootSS(rts));
31533 } else {
31534 ssSetRTModel(childS,ssGetRTModel(rts));
31535 _ssSetParentSS(childS, (NULL));
31536 _ssSetRootSS(childS, childS);
31537 }
31538
31539 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
31540
31541 /* work vectors */
31542 {
31543 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
31544 (4 * sizeof(struct _ssDWorkRecord));
31545 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
31546 calloc(4, sizeof(struct _ssDWorkAuxRecord));
31547 ss_VALIDATE_MEMORY(rts,dWorkRecord);
31548 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
31549 ssSetSFcnDWork(childS, dWorkRecord);
31550 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
31551 _ssSetNumDWork(childS, 4);
31552
31553 /* DWORK0 */
31554 ssSetDWorkWidth(childS, 0, 1);
31555 ssSetDWorkDataType(childS, 0,SS_SINGLE);
31556 ssSetDWorkComplexSignal(childS, 0, 0);
31557 ssSetDWorkUsedAsDState(childS, 0, 1);
31558 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 236))[0]);
31559
31560 /* DWORK1 */
31561 ssSetDWorkWidth(childS, 1, 1);
31562 ssSetDWorkDataType(childS, 1,SS_SINGLE);
31563 ssSetDWorkComplexSignal(childS, 1, 0);
31564 ssSetDWorkUsedAsDState(childS, 1, 1);
31565 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 237))[0]);
31566
31567 /* DWORK2 */
31568 ssSetDWorkWidth(childS, 2, 1);
31569 ssSetDWorkDataType(childS, 2,SS_INT8);
31570 ssSetDWorkComplexSignal(childS, 2, 0);
31571 ssSetDWorkUsedAsDState(childS, 2, 1);
31572 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 463))[0]);
31573
31574 /* DWORK3 */
31575 ssSetDWorkWidth(childS, 3, 1);
31576 ssSetDWorkDataType(childS, 3,SS_INT8);
31577 ssSetDWorkComplexSignal(childS, 3, 0);
31578 ssSetDWorkUsedAsDState(childS, 3, 1);
31579 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 464))[0]);
31580 }
31581
31582 (childS)->regDataType.arg1 = ((void *)(childS));
31583 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
31584 FcnSetErrorStatus);
31585 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
31586 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
31587 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
31588 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
31589
31590 /* registration */
31591#if defined(MATLAB_MEX_FILE)
31592
31593 {
31594 int_T i;
31595 mxArray *plhs[1];
31596 mxArray *prhs[4];
31597 double *pr;
31598 volatile int_T *intS = (int_T *)&childS;
31599 int_T addrlen = sizeof(SimStruct *);
31600 int_T m = addrlen/sizeof(int_T) + 1;
31601 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
31602 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
31603 pr = mxGetPr(prhs[1]);
31604 for (i = 0; i < m - 1; i++) {
31605 pr[i] = (double)intS[i];
31606 }
31607
31608 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
31609 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
31610 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
31611
31612 /* Reset port dimensions info functions because the S-function
31613 * and accelerator mex-files explicitly set their dimensions,
31614 * i.e., they are not dynamically sized. For this case, the
31615 * mex-file is responsible for the dimensions info memory
31616 * and Simulink should not free it. This is achieved by
31617 * setting the following two methods to NULL.
31618 */
31619 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
31620 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
31621
31622 /*
31623 * Setup function pointers and call mdlInitializeSizes via
31624 * simulink.c
31625 */
31626 mexCallMATLAB(1, plhs, 4, prhs, "LeadLagFilter_sf");
31627 mxDestroyArray(plhs[0]);
31628 mxDestroyArray(prhs[0]);
31629 mxDestroyArray(prhs[1]);
31630 mxDestroyArray(prhs[2]);
31631 mxDestroyArray(prhs[3]);
31632 }
31633
31634#else
31635
31636 {
31637 LeadLagFilter_sf(childS);
31638 sfcnInitializeSizes(childS);
31639 }
31640
31641#endif
31642
31643 sfcnInitializeSampleTimes(childS);
31644
31645 /* adjust sample time */
31646 ssSetSampleTime(childS, 0, 0.0);
31647 ssSetOffsetTime(childS, 0, 0.0);
31648 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
31649
31650 /* set compiled values of dynamic vector attributes */
31651 ssSetNumNonsampledZCs(childS, 0);
31652
31653 /* Update connectivity flags for each port */
31654 _ssSetInputPortConnected(childS, 0, 1);
31655 _ssSetInputPortConnected(childS, 1, 1);
31656 _ssSetInputPortConnected(childS, 2, 1);
31657 _ssSetInputPortConnected(childS, 3, 1);
31658 _ssSetInputPortConnected(childS, 4, 1);
31659 _ssSetInputPortConnected(childS, 5, 1);
31660 _ssSetInputPortConnected(childS, 6, 1);
31661 _ssSetOutputPortConnected(childS, 0, 1);
31662 _ssSetOutputPortBeingMerged(childS, 0, 0);
31663
31664 /* Update the BufferDstPort flags for each input port */
31665 _ssSetInputPortBufferDstPort(childS, 0, -1);
31666 _ssSetInputPortBufferDstPort(childS, 1, -1);
31667 _ssSetInputPortBufferDstPort(childS, 2, -1);
31668 _ssSetInputPortBufferDstPort(childS, 3, -1);
31669 _ssSetInputPortBufferDstPort(childS, 4, -1);
31670 _ssSetInputPortBufferDstPort(childS, 5, -1);
31671 _ssSetInputPortBufferDstPort(childS, 6, -1);
31672 }
31673
31674 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S74>/Generated S-Function4 (LagFilter_sf) */
31675 {
31676 SimStruct *childS = ssGetSFunction(rts, 120);
31677
31678 /* timing info */
31679 time_T *sfcnPeriod;
31680 time_T *sfcnOffset;
31681 int_T *sfcnTsMap;
31682 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
31683 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
31684 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
31685 ss_VALIDATE_MEMORY(rts,sfcnOffset);
31686 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
31687 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
31688 (void) memset((void*)sfcnPeriod, 0,
31689 sizeof(time_T)*1);
31690 (void) memset((void*)sfcnOffset, 0,
31691 sizeof(time_T)*1);
31692 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
31693 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
31694 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
31695
31696 /* Set up the mdlInfo pointer */
31697# ifdef USE_RTMODEL
31698
31699 {
31700 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
31701 struct _ssBlkInfo2));
31702 ss_VALIDATE_MEMORY(rts,blkInfo2);
31703 ssSetBlkInfo2Ptr(childS, blkInfo2);
31704 }
31705
31706 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
31707
31708# else
31709
31710 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
31711
31712# endif /* USE_RTMODEL */
31713
31714 /* Allocate memory of model methods 2 */
31715 {
31716 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
31717 malloc(sizeof(struct _ssSFcnModelMethods2));
31718 ss_VALIDATE_MEMORY(rts,methods2);
31719 ssSetModelMethods2(childS, methods2);
31720 }
31721
31722 /* Allocate memory of model methods 3 */
31723 {
31724 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
31725 malloc(sizeof(struct _ssSFcnModelMethods3));
31726 ss_VALIDATE_MEMORY(rts,methods3);
31727 ssSetModelMethods3(childS, methods3);
31728 }
31729
31730 /* Allocate memory for states auxilliary information */
31731 {
31732 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
31733 (sizeof(struct _ssStatesInfo2));
31734 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
31735 malloc(sizeof(ssPeriodicStatesInfo));
31736 ss_VALIDATE_MEMORY(rts,statesInfo2);
31737 ssSetStatesInfo2(childS, statesInfo2);
31738 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
31739 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
31740 }
31741
31742 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
31743 RegNumInputPorts);
31744 ssSetRegNumInputPortsFcnArg(childS,childS);
31745
31746 /* inputs */
31747 {
31748 struct _ssPortInputs *inputPortInfo =
31749 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
31750 ss_VALIDATE_MEMORY(rts,inputPortInfo);
31751 _ssSetNumInputPorts(childS, 6);
31752 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
31753
31754 /* port 0 */
31755 {
31756 real32_T const **sfcnUPtrs = (real32_T const **)
31757 malloc(1 * sizeof(real32_T *));
31758 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31759 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
31760 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReuseS;
31761 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
31762 _ssSetInputPortNumDimensions(childS, 0, 1);
31763 ssSetInputPortWidth(childS, 0, 1);
31764 }
31765
31766 /* port 1 */
31767 {
31768 int8_T const **sfcnUPtrs = (int8_T const **)
31769 malloc(1 * sizeof(int8_T *));
31770 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31771 sfcnUPtrs[0] = (int8_T const *) &((B_AFCS_MODEL1_T *)
31772 ssGetLocalBlockIO(rts))->DataTypeConversion1_jy;
31773 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
31774 _ssSetInputPortNumDimensions(childS, 1, 1);
31775 ssSetInputPortWidth(childS, 1, 1);
31776 }
31777
31778 /* port 2 */
31779 {
31780 real32_T const **sfcnUPtrs = (real32_T const **)
31781 malloc(1 * sizeof(real32_T *));
31782 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31783 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled107;
31784 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
31785 _ssSetInputPortNumDimensions(childS, 2, 1);
31786 ssSetInputPortWidth(childS, 2, 1);
31787 }
31788
31789 /* port 3 */
31790 {
31791 real32_T const **sfcnUPtrs = (real32_T const **)
31792 malloc(1 * sizeof(real32_T *));
31793 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31794 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
31795 ssGetLocalBlockIO(rts))->Switch_fz;
31796 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
31797 _ssSetInputPortNumDimensions(childS, 3, 1);
31798 ssSetInputPortWidth(childS, 3, 1);
31799 }
31800
31801 /* port 4 */
31802 {
31803 real32_T const **sfcnUPtrs = (real32_T const **)
31804 malloc(1 * sizeof(real32_T *));
31805 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31806 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
31807 ssGetLocalBlockIO(rts))->Switch_fz;
31808 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
31809 _ssSetInputPortNumDimensions(childS, 4, 1);
31810 ssSetInputPortWidth(childS, 4, 1);
31811 }
31812
31813 /* port 5 */
31814 {
31815 real32_T const **sfcnUPtrs = (real32_T const **)
31816 malloc(1 * sizeof(real32_T *));
31817 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
31818 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
31819 ssGetLocalBlockIO(rts))->GeneratedSFunction2_m5;
31820 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
31821 _ssSetInputPortNumDimensions(childS, 5, 1);
31822 ssSetInputPortWidth(childS, 5, 1);
31823 }
31824 }
31825
31826 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
31827 RegNumOutputPorts);
31828 ssSetRegNumOutputPortsFcnArg(childS,childS);
31829
31830 /* outputs */
31831 {
31832 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
31833 calloc(1, sizeof(struct _ssPortOutputs));
31834 ss_VALIDATE_MEMORY(rts,outputPortInfo);
31835 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
31836 _ssSetNumOutputPorts(childS, 1);
31837
31838 /* port 0 */
31839 {
31840 _ssSetOutputPortNumDimensions(childS, 0, 1);
31841 ssSetOutputPortWidth(childS, 0, 1);
31842 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
31843 ssGetLocalBlockIO(rts))->GeneratedSFunction4_cw));
31844 }
31845 }
31846
31847 /* path info */
31848 _ssSetModelName(childS, "LagFilter_sf");
31849 _ssSetPath(childS,
31850 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/Autopilot/NWScontrol/RwyLControl/ lag filter/Generated S-Function4");
31851 if (ssGetRTModel(rts) == (NULL)) {
31852 _ssSetParentSS(childS, rts);
31853 _ssSetRootSS(childS, ssGetRootSS(rts));
31854 } else {
31855 ssSetRTModel(childS,ssGetRTModel(rts));
31856 _ssSetParentSS(childS, (NULL));
31857 _ssSetRootSS(childS, childS);
31858 }
31859
31860 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
31861
31862 /* work vectors */
31863 {
31864 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
31865 (4 * sizeof(struct _ssDWorkRecord));
31866 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
31867 calloc(4, sizeof(struct _ssDWorkAuxRecord));
31868 ss_VALIDATE_MEMORY(rts,dWorkRecord);
31869 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
31870 ssSetSFcnDWork(childS, dWorkRecord);
31871 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
31872 _ssSetNumDWork(childS, 4);
31873
31874 /* DWORK0 */
31875 ssSetDWorkWidth(childS, 0, 1);
31876 ssSetDWorkDataType(childS, 0,SS_SINGLE);
31877 ssSetDWorkComplexSignal(childS, 0, 0);
31878 ssSetDWorkUsedAsDState(childS, 0, 1);
31879 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 238))[0]);
31880
31881 /* DWORK1 */
31882 ssSetDWorkWidth(childS, 1, 1);
31883 ssSetDWorkDataType(childS, 1,SS_SINGLE);
31884 ssSetDWorkComplexSignal(childS, 1, 0);
31885 ssSetDWorkUsedAsDState(childS, 1, 1);
31886 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 239))[0]);
31887
31888 /* DWORK2 */
31889 ssSetDWorkWidth(childS, 2, 1);
31890 ssSetDWorkDataType(childS, 2,SS_INT8);
31891 ssSetDWorkComplexSignal(childS, 2, 0);
31892 ssSetDWorkUsedAsDState(childS, 2, 1);
31893 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 465))[0]);
31894
31895 /* DWORK3 */
31896 ssSetDWorkWidth(childS, 3, 1);
31897 ssSetDWorkDataType(childS, 3,SS_INT8);
31898 ssSetDWorkComplexSignal(childS, 3, 0);
31899 ssSetDWorkUsedAsDState(childS, 3, 1);
31900 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 466))[0]);
31901 }
31902
31903 (childS)->regDataType.arg1 = ((void *)(childS));
31904 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
31905 FcnSetErrorStatus);
31906 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
31907 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
31908 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
31909 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
31910
31911 /* registration */
31912#if defined(MATLAB_MEX_FILE)
31913
31914 {
31915 int_T i;
31916 mxArray *plhs[1];
31917 mxArray *prhs[4];
31918 double *pr;
31919 volatile int_T *intS = (int_T *)&childS;
31920 int_T addrlen = sizeof(SimStruct *);
31921 int_T m = addrlen/sizeof(int_T) + 1;
31922 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
31923 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
31924 pr = mxGetPr(prhs[1]);
31925 for (i = 0; i < m - 1; i++) {
31926 pr[i] = (double)intS[i];
31927 }
31928
31929 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
31930 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
31931 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
31932
31933 /* Reset port dimensions info functions because the S-function
31934 * and accelerator mex-files explicitly set their dimensions,
31935 * i.e., they are not dynamically sized. For this case, the
31936 * mex-file is responsible for the dimensions info memory
31937 * and Simulink should not free it. This is achieved by
31938 * setting the following two methods to NULL.
31939 */
31940 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
31941 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
31942
31943 /*
31944 * Setup function pointers and call mdlInitializeSizes via
31945 * simulink.c
31946 */
31947 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
31948 mxDestroyArray(plhs[0]);
31949 mxDestroyArray(prhs[0]);
31950 mxDestroyArray(prhs[1]);
31951 mxDestroyArray(prhs[2]);
31952 mxDestroyArray(prhs[3]);
31953 }
31954
31955#else
31956
31957 {
31958 LagFilter_sf(childS);
31959 sfcnInitializeSizes(childS);
31960 }
31961
31962#endif
31963
31964 sfcnInitializeSampleTimes(childS);
31965
31966 /* adjust sample time */
31967 ssSetSampleTime(childS, 0, 0.0);
31968 ssSetOffsetTime(childS, 0, 0.0);
31969 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
31970
31971 /* set compiled values of dynamic vector attributes */
31972 ssSetNumNonsampledZCs(childS, 0);
31973
31974 /* Update connectivity flags for each port */
31975 _ssSetInputPortConnected(childS, 0, 1);
31976 _ssSetInputPortConnected(childS, 1, 1);
31977 _ssSetInputPortConnected(childS, 2, 1);
31978 _ssSetInputPortConnected(childS, 3, 1);
31979 _ssSetInputPortConnected(childS, 4, 1);
31980 _ssSetInputPortConnected(childS, 5, 1);
31981 _ssSetOutputPortConnected(childS, 0, 1);
31982 _ssSetOutputPortBeingMerged(childS, 0, 0);
31983
31984 /* Update the BufferDstPort flags for each input port */
31985 _ssSetInputPortBufferDstPort(childS, 0, -1);
31986 _ssSetInputPortBufferDstPort(childS, 1, -1);
31987 _ssSetInputPortBufferDstPort(childS, 2, -1);
31988 _ssSetInputPortBufferDstPort(childS, 3, -1);
31989 _ssSetInputPortBufferDstPort(childS, 4, -1);
31990 _ssSetInputPortBufferDstPort(childS, 5, -1);
31991 }
31992
31993 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S209>/Generated S-Function1 (SaturationLimiter_sf) */
31994 {
31995 SimStruct *childS = ssGetSFunction(rts, 121);
31996
31997 /* timing info */
31998 time_T *sfcnPeriod;
31999 time_T *sfcnOffset;
32000 int_T *sfcnTsMap;
32001 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
32002 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
32003 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
32004 ss_VALIDATE_MEMORY(rts,sfcnOffset);
32005 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
32006 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
32007 (void) memset((void*)sfcnPeriod, 0,
32008 sizeof(time_T)*1);
32009 (void) memset((void*)sfcnOffset, 0,
32010 sizeof(time_T)*1);
32011 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
32012 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
32013 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
32014
32015 /* Set up the mdlInfo pointer */
32016# ifdef USE_RTMODEL
32017
32018 {
32019 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
32020 struct _ssBlkInfo2));
32021 ss_VALIDATE_MEMORY(rts,blkInfo2);
32022 ssSetBlkInfo2Ptr(childS, blkInfo2);
32023 }
32024
32025 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
32026
32027# else
32028
32029 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
32030
32031# endif /* USE_RTMODEL */
32032
32033 /* Allocate memory of model methods 2 */
32034 {
32035 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
32036 malloc(sizeof(struct _ssSFcnModelMethods2));
32037 ss_VALIDATE_MEMORY(rts,methods2);
32038 ssSetModelMethods2(childS, methods2);
32039 }
32040
32041 /* Allocate memory of model methods 3 */
32042 {
32043 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
32044 malloc(sizeof(struct _ssSFcnModelMethods3));
32045 ss_VALIDATE_MEMORY(rts,methods3);
32046 ssSetModelMethods3(childS, methods3);
32047 }
32048
32049 /* Allocate memory for states auxilliary information */
32050 {
32051 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
32052 (sizeof(struct _ssStatesInfo2));
32053 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
32054 malloc(sizeof(ssPeriodicStatesInfo));
32055 ss_VALIDATE_MEMORY(rts,statesInfo2);
32056 ssSetStatesInfo2(childS, statesInfo2);
32057 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
32058 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
32059 }
32060
32061 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
32062 RegNumInputPorts);
32063 ssSetRegNumInputPortsFcnArg(childS,childS);
32064
32065 /* inputs */
32066 {
32067 struct _ssPortInputs *inputPortInfo =
32068 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
32069 ss_VALIDATE_MEMORY(rts,inputPortInfo);
32070 _ssSetNumInputPorts(childS, 3);
32071 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
32072
32073 /* port 0 */
32074 {
32075 real32_T const **sfcnUPtrs = (real32_T const **)
32076 malloc(1 * sizeof(real32_T *));
32077 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32078 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32079 ssGetLocalBlockIO(rts))->Switch_lr;
32080 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
32081 _ssSetInputPortNumDimensions(childS, 0, 1);
32082 ssSetInputPortWidth(childS, 0, 1);
32083 }
32084
32085 /* port 1 */
32086 {
32087 real32_T const **sfcnUPtrs = (real32_T const **)
32088 malloc(1 * sizeof(real32_T *));
32089 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32090 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
32091 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
32092 _ssSetInputPortNumDimensions(childS, 1, 1);
32093 ssSetInputPortWidth(childS, 1, 1);
32094 }
32095
32096 /* port 2 */
32097 {
32098 real32_T const **sfcnUPtrs = (real32_T const **)
32099 malloc(1 * sizeof(real32_T *));
32100 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32101 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
32102 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
32103 _ssSetInputPortNumDimensions(childS, 2, 1);
32104 ssSetInputPortWidth(childS, 2, 1);
32105 }
32106 }
32107
32108 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
32109 RegNumOutputPorts);
32110 ssSetRegNumOutputPortsFcnArg(childS,childS);
32111
32112 /* outputs */
32113 {
32114 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
32115 calloc(1, sizeof(struct _ssPortOutputs));
32116 ss_VALIDATE_MEMORY(rts,outputPortInfo);
32117 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
32118 _ssSetNumOutputPorts(childS, 1);
32119
32120 /* port 0 */
32121 {
32122 _ssSetOutputPortNumDimensions(childS, 0, 1);
32123 ssSetOutputPortWidth(childS, 0, 1);
32124 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
32125 ssGetLocalBlockIO(rts))->GeneratedSFunction1_oi));
32126 }
32127 }
32128
32129 /* path info */
32130 _ssSetModelName(childS, "SaturationLimiter_sf");
32131 _ssSetPath(childS,
32132 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/Saturation Limiter/Generated S-Function1");
32133 if (ssGetRTModel(rts) == (NULL)) {
32134 _ssSetParentSS(childS, rts);
32135 _ssSetRootSS(childS, ssGetRootSS(rts));
32136 } else {
32137 ssSetRTModel(childS,ssGetRTModel(rts));
32138 _ssSetParentSS(childS, (NULL));
32139 _ssSetRootSS(childS, childS);
32140 }
32141
32142 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
32143 (childS)->regDataType.arg1 = ((void *)(childS));
32144 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
32145 FcnSetErrorStatus);
32146 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
32147 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
32148 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
32149 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
32150
32151 /* registration */
32152#if defined(MATLAB_MEX_FILE)
32153
32154 {
32155 int_T i;
32156 mxArray *plhs[1];
32157 mxArray *prhs[4];
32158 double *pr;
32159 volatile int_T *intS = (int_T *)&childS;
32160 int_T addrlen = sizeof(SimStruct *);
32161 int_T m = addrlen/sizeof(int_T) + 1;
32162 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
32163 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
32164 pr = mxGetPr(prhs[1]);
32165 for (i = 0; i < m - 1; i++) {
32166 pr[i] = (double)intS[i];
32167 }
32168
32169 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
32170 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
32171 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
32172
32173 /* Reset port dimensions info functions because the S-function
32174 * and accelerator mex-files explicitly set their dimensions,
32175 * i.e., they are not dynamically sized. For this case, the
32176 * mex-file is responsible for the dimensions info memory
32177 * and Simulink should not free it. This is achieved by
32178 * setting the following two methods to NULL.
32179 */
32180 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
32181 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
32182
32183 /*
32184 * Setup function pointers and call mdlInitializeSizes via
32185 * simulink.c
32186 */
32187 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
32188 mxDestroyArray(plhs[0]);
32189 mxDestroyArray(prhs[0]);
32190 mxDestroyArray(prhs[1]);
32191 mxDestroyArray(prhs[2]);
32192 mxDestroyArray(prhs[3]);
32193 }
32194
32195#else
32196
32197 {
32198 SaturationLimiter_sf(childS);
32199 sfcnInitializeSizes(childS);
32200 }
32201
32202#endif
32203
32204 sfcnInitializeSampleTimes(childS);
32205
32206 /* adjust sample time */
32207 ssSetSampleTime(childS, 0, 0.0);
32208 ssSetOffsetTime(childS, 0, 0.0);
32209 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
32210
32211 /* set compiled values of dynamic vector attributes */
32212 ssSetNumNonsampledZCs(childS, 0);
32213
32214 /* Update connectivity flags for each port */
32215 _ssSetInputPortConnected(childS, 0, 1);
32216 _ssSetInputPortConnected(childS, 1, 1);
32217 _ssSetInputPortConnected(childS, 2, 1);
32218 _ssSetOutputPortConnected(childS, 0, 1);
32219 _ssSetOutputPortBeingMerged(childS, 0, 0);
32220
32221 /* Update the BufferDstPort flags for each input port */
32222 _ssSetInputPortBufferDstPort(childS, 0, -1);
32223 _ssSetInputPortBufferDstPort(childS, 1, -1);
32224 _ssSetInputPortBufferDstPort(childS, 2, -1);
32225 }
32226
32227 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S208>/Generated S-Function (RateLimiter_sf) */
32228 {
32229 SimStruct *childS = ssGetSFunction(rts, 122);
32230
32231 /* timing info */
32232 time_T *sfcnPeriod;
32233 time_T *sfcnOffset;
32234 int_T *sfcnTsMap;
32235 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
32236 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
32237 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
32238 ss_VALIDATE_MEMORY(rts,sfcnOffset);
32239 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
32240 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
32241 (void) memset((void*)sfcnPeriod, 0,
32242 sizeof(time_T)*1);
32243 (void) memset((void*)sfcnOffset, 0,
32244 sizeof(time_T)*1);
32245 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
32246 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
32247 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
32248
32249 /* Set up the mdlInfo pointer */
32250# ifdef USE_RTMODEL
32251
32252 {
32253 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
32254 struct _ssBlkInfo2));
32255 ss_VALIDATE_MEMORY(rts,blkInfo2);
32256 ssSetBlkInfo2Ptr(childS, blkInfo2);
32257 }
32258
32259 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
32260
32261# else
32262
32263 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
32264
32265# endif /* USE_RTMODEL */
32266
32267 /* Allocate memory of model methods 2 */
32268 {
32269 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
32270 malloc(sizeof(struct _ssSFcnModelMethods2));
32271 ss_VALIDATE_MEMORY(rts,methods2);
32272 ssSetModelMethods2(childS, methods2);
32273 }
32274
32275 /* Allocate memory of model methods 3 */
32276 {
32277 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
32278 malloc(sizeof(struct _ssSFcnModelMethods3));
32279 ss_VALIDATE_MEMORY(rts,methods3);
32280 ssSetModelMethods3(childS, methods3);
32281 }
32282
32283 /* Allocate memory for states auxilliary information */
32284 {
32285 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
32286 (sizeof(struct _ssStatesInfo2));
32287 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
32288 malloc(sizeof(ssPeriodicStatesInfo));
32289 ss_VALIDATE_MEMORY(rts,statesInfo2);
32290 ssSetStatesInfo2(childS, statesInfo2);
32291 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
32292 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
32293 }
32294
32295 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
32296 RegNumInputPorts);
32297 ssSetRegNumInputPortsFcnArg(childS,childS);
32298
32299 /* inputs */
32300 {
32301 struct _ssPortInputs *inputPortInfo =
32302 (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));
32303 ss_VALIDATE_MEMORY(rts,inputPortInfo);
32304 _ssSetNumInputPorts(childS, 5);
32305 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
32306
32307 /* port 0 */
32308 {
32309 int8_T const **sfcnUPtrs = (int8_T const **)
32310 malloc(1 * sizeof(int8_T *));
32311 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32312 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
32313 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
32314 _ssSetInputPortNumDimensions(childS, 0, 1);
32315 ssSetInputPortWidth(childS, 0, 1);
32316 }
32317
32318 /* port 1 */
32319 {
32320 real32_T const **sfcnUPtrs = (real32_T const **)
32321 malloc(1 * sizeof(real32_T *));
32322 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32323 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32324 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReus_b[5];
32325 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
32326 _ssSetInputPortNumDimensions(childS, 1, 1);
32327 ssSetInputPortWidth(childS, 1, 1);
32328 }
32329
32330 /* port 2 */
32331 {
32332 real32_T const **sfcnUPtrs = (real32_T const **)
32333 malloc(1 * sizeof(real32_T *));
32334 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32335 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled123;
32336 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
32337 _ssSetInputPortNumDimensions(childS, 2, 1);
32338 ssSetInputPortWidth(childS, 2, 1);
32339 }
32340
32341 /* port 3 */
32342 {
32343 real32_T const **sfcnUPtrs = (real32_T const **)
32344 malloc(1 * sizeof(real32_T *));
32345 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32346 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32347 ssGetLocalBlockIO(rts))->dtCAS;
32348 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
32349 _ssSetInputPortNumDimensions(childS, 3, 1);
32350 ssSetInputPortWidth(childS, 3, 1);
32351 }
32352
32353 /* port 4 */
32354 {
32355 real32_T const **sfcnUPtrs = (real32_T const **)
32356 malloc(1 * sizeof(real32_T *));
32357 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32358 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32359 ssGetLocalBlockIO(rts))->GeneratedSFunction1_oi;
32360 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
32361 _ssSetInputPortNumDimensions(childS, 4, 1);
32362 ssSetInputPortWidth(childS, 4, 1);
32363 }
32364 }
32365
32366 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
32367 RegNumOutputPorts);
32368 ssSetRegNumOutputPortsFcnArg(childS,childS);
32369
32370 /* outputs */
32371 {
32372 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
32373 calloc(2, sizeof(struct _ssPortOutputs));
32374 ss_VALIDATE_MEMORY(rts,outputPortInfo);
32375 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
32376 _ssSetNumOutputPorts(childS, 2);
32377
32378 /* port 0 */
32379 {
32380 _ssSetOutputPortNumDimensions(childS, 0, 1);
32381 ssSetOutputPortWidth(childS, 0, 1);
32382 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
32383 ssGetLocalBlockIO(rts))->GeneratedSFunction_o1));
32384 }
32385
32386 /* port 1 */
32387 {
32388 _ssSetOutputPortNumDimensions(childS, 1, 1);
32389 ssSetOutputPortWidth(childS, 1, 1);
32390 _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)
32391 ssGetLocalBlockIO(rts))->GeneratedSFunction_o2));
32392 }
32393 }
32394
32395 /* path info */
32396 _ssSetModelName(childS, "RateLimiter_sf");
32397 _ssSetPath(childS,
32398 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/Rate Limiter/Generated S-Function");
32399 if (ssGetRTModel(rts) == (NULL)) {
32400 _ssSetParentSS(childS, rts);
32401 _ssSetRootSS(childS, ssGetRootSS(rts));
32402 } else {
32403 ssSetRTModel(childS,ssGetRTModel(rts));
32404 _ssSetParentSS(childS, (NULL));
32405 _ssSetRootSS(childS, childS);
32406 }
32407
32408 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
32409
32410 /* work vectors */
32411 {
32412 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
32413 (3 * sizeof(struct _ssDWorkRecord));
32414 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
32415 calloc(3, sizeof(struct _ssDWorkAuxRecord));
32416 ss_VALIDATE_MEMORY(rts,dWorkRecord);
32417 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
32418 ssSetSFcnDWork(childS, dWorkRecord);
32419 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
32420 _ssSetNumDWork(childS, 3);
32421
32422 /* DWORK0 */
32423 ssSetDWorkWidth(childS, 0, 1);
32424 ssSetDWorkDataType(childS, 0,SS_SINGLE);
32425 ssSetDWorkComplexSignal(childS, 0, 0);
32426 ssSetDWorkUsedAsDState(childS, 0, 1);
32427 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 240))[0]);
32428
32429 /* DWORK1 */
32430 ssSetDWorkWidth(childS, 1, 1);
32431 ssSetDWorkDataType(childS, 1,SS_INT8);
32432 ssSetDWorkComplexSignal(childS, 1, 0);
32433 ssSetDWorkUsedAsDState(childS, 1, 1);
32434 _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 467))[0]);
32435
32436 /* DWORK2 */
32437 ssSetDWorkWidth(childS, 2, 1);
32438 ssSetDWorkDataType(childS, 2,SS_INT8);
32439 ssSetDWorkComplexSignal(childS, 2, 0);
32440 ssSetDWorkUsedAsDState(childS, 2, 1);
32441 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 468))[0]);
32442 }
32443
32444 (childS)->regDataType.arg1 = ((void *)(childS));
32445 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
32446 FcnSetErrorStatus);
32447 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
32448 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
32449 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
32450 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
32451
32452 /* registration */
32453#if defined(MATLAB_MEX_FILE)
32454
32455 {
32456 int_T i;
32457 mxArray *plhs[1];
32458 mxArray *prhs[4];
32459 double *pr;
32460 volatile int_T *intS = (int_T *)&childS;
32461 int_T addrlen = sizeof(SimStruct *);
32462 int_T m = addrlen/sizeof(int_T) + 1;
32463 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
32464 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
32465 pr = mxGetPr(prhs[1]);
32466 for (i = 0; i < m - 1; i++) {
32467 pr[i] = (double)intS[i];
32468 }
32469
32470 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
32471 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
32472 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
32473
32474 /* Reset port dimensions info functions because the S-function
32475 * and accelerator mex-files explicitly set their dimensions,
32476 * i.e., they are not dynamically sized. For this case, the
32477 * mex-file is responsible for the dimensions info memory
32478 * and Simulink should not free it. This is achieved by
32479 * setting the following two methods to NULL.
32480 */
32481 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
32482 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
32483
32484 /*
32485 * Setup function pointers and call mdlInitializeSizes via
32486 * simulink.c
32487 */
32488 mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");
32489 mxDestroyArray(plhs[0]);
32490 mxDestroyArray(prhs[0]);
32491 mxDestroyArray(prhs[1]);
32492 mxDestroyArray(prhs[2]);
32493 mxDestroyArray(prhs[3]);
32494 }
32495
32496#else
32497
32498 {
32499 RateLimiter_sf(childS);
32500 sfcnInitializeSizes(childS);
32501 }
32502
32503#endif
32504
32505 sfcnInitializeSampleTimes(childS);
32506
32507 /* adjust sample time */
32508 ssSetSampleTime(childS, 0, 0.0);
32509 ssSetOffsetTime(childS, 0, 0.0);
32510 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
32511
32512 /* set compiled values of dynamic vector attributes */
32513 ssSetNumNonsampledZCs(childS, 0);
32514
32515 /* Update connectivity flags for each port */
32516 _ssSetInputPortConnected(childS, 0, 1);
32517 _ssSetInputPortConnected(childS, 1, 1);
32518 _ssSetInputPortConnected(childS, 2, 1);
32519 _ssSetInputPortConnected(childS, 3, 1);
32520 _ssSetInputPortConnected(childS, 4, 1);
32521 _ssSetOutputPortConnected(childS, 0, 1);
32522 _ssSetOutputPortConnected(childS, 1, 1);
32523 _ssSetOutputPortBeingMerged(childS, 0, 0);
32524 _ssSetOutputPortBeingMerged(childS, 1, 0);
32525
32526 /* Update the BufferDstPort flags for each input port */
32527 _ssSetInputPortBufferDstPort(childS, 0, -1);
32528 _ssSetInputPortBufferDstPort(childS, 1, -1);
32529 _ssSetInputPortBufferDstPort(childS, 2, -1);
32530 _ssSetInputPortBufferDstPort(childS, 3, -1);
32531 _ssSetInputPortBufferDstPort(childS, 4, -1);
32532 }
32533
32534 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S241>/Generated S-Function4 (LagFilter_sf) */
32535 {
32536 SimStruct *childS = ssGetSFunction(rts, 123);
32537
32538 /* timing info */
32539 time_T *sfcnPeriod;
32540 time_T *sfcnOffset;
32541 int_T *sfcnTsMap;
32542 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
32543 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
32544 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
32545 ss_VALIDATE_MEMORY(rts,sfcnOffset);
32546 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
32547 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
32548 (void) memset((void*)sfcnPeriod, 0,
32549 sizeof(time_T)*1);
32550 (void) memset((void*)sfcnOffset, 0,
32551 sizeof(time_T)*1);
32552 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
32553 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
32554 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
32555
32556 /* Set up the mdlInfo pointer */
32557# ifdef USE_RTMODEL
32558
32559 {
32560 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
32561 struct _ssBlkInfo2));
32562 ss_VALIDATE_MEMORY(rts,blkInfo2);
32563 ssSetBlkInfo2Ptr(childS, blkInfo2);
32564 }
32565
32566 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
32567
32568# else
32569
32570 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
32571
32572# endif /* USE_RTMODEL */
32573
32574 /* Allocate memory of model methods 2 */
32575 {
32576 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
32577 malloc(sizeof(struct _ssSFcnModelMethods2));
32578 ss_VALIDATE_MEMORY(rts,methods2);
32579 ssSetModelMethods2(childS, methods2);
32580 }
32581
32582 /* Allocate memory of model methods 3 */
32583 {
32584 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
32585 malloc(sizeof(struct _ssSFcnModelMethods3));
32586 ss_VALIDATE_MEMORY(rts,methods3);
32587 ssSetModelMethods3(childS, methods3);
32588 }
32589
32590 /* Allocate memory for states auxilliary information */
32591 {
32592 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
32593 (sizeof(struct _ssStatesInfo2));
32594 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
32595 malloc(sizeof(ssPeriodicStatesInfo));
32596 ss_VALIDATE_MEMORY(rts,statesInfo2);
32597 ssSetStatesInfo2(childS, statesInfo2);
32598 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
32599 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
32600 }
32601
32602 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
32603 RegNumInputPorts);
32604 ssSetRegNumInputPortsFcnArg(childS,childS);
32605
32606 /* inputs */
32607 {
32608 struct _ssPortInputs *inputPortInfo =
32609 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
32610 ss_VALIDATE_MEMORY(rts,inputPortInfo);
32611 _ssSetNumInputPorts(childS, 6);
32612 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
32613
32614 /* port 0 */
32615 {
32616 real32_T const **sfcnUPtrs = (real32_T const **)
32617 malloc(1 * sizeof(real32_T *));
32618 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32619 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32620 ssGetLocalBlockIO(rts))->dtCAS;
32621 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
32622 _ssSetInputPortNumDimensions(childS, 0, 1);
32623 ssSetInputPortWidth(childS, 0, 1);
32624 }
32625
32626 /* port 1 */
32627 {
32628 int8_T const **sfcnUPtrs = (int8_T const **)
32629 malloc(1 * sizeof(int8_T *));
32630 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32631 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
32632 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
32633 _ssSetInputPortNumDimensions(childS, 1, 1);
32634 ssSetInputPortWidth(childS, 1, 1);
32635 }
32636
32637 /* port 2 */
32638 {
32639 real32_T const **sfcnUPtrs = (real32_T const **)
32640 malloc(1 * sizeof(real32_T *));
32641 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32642 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled126;
32643 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
32644 _ssSetInputPortNumDimensions(childS, 2, 1);
32645 ssSetInputPortWidth(childS, 2, 1);
32646 }
32647
32648 /* port 3 */
32649 {
32650 real32_T const **sfcnUPtrs = (real32_T const **)
32651 malloc(1 * sizeof(real32_T *));
32652 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32653 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32654 ssGetLocalBlockIO(rts))->Saturation_ll;
32655 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
32656 _ssSetInputPortNumDimensions(childS, 3, 1);
32657 ssSetInputPortWidth(childS, 3, 1);
32658 }
32659
32660 /* port 4 */
32661 {
32662 real32_T const **sfcnUPtrs = (real32_T const **)
32663 malloc(1 * sizeof(real32_T *));
32664 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32665 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32666 ssGetLocalBlockIO(rts))->Saturation_ll;
32667 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
32668 _ssSetInputPortNumDimensions(childS, 4, 1);
32669 ssSetInputPortWidth(childS, 4, 1);
32670 }
32671
32672 /* port 5 */
32673 {
32674 real32_T const **sfcnUPtrs = (real32_T const **)
32675 malloc(1 * sizeof(real32_T *));
32676 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32677 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32678 ssGetLocalBlockIO(rts))->Saturation_ll;
32679 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
32680 _ssSetInputPortNumDimensions(childS, 5, 1);
32681 ssSetInputPortWidth(childS, 5, 1);
32682 }
32683 }
32684
32685 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
32686 RegNumOutputPorts);
32687 ssSetRegNumOutputPortsFcnArg(childS,childS);
32688
32689 /* outputs */
32690 {
32691 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
32692 calloc(1, sizeof(struct _ssPortOutputs));
32693 ss_VALIDATE_MEMORY(rts,outputPortInfo);
32694 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
32695 _ssSetNumOutputPorts(childS, 1);
32696
32697 /* port 0 */
32698 {
32699 _ssSetOutputPortNumDimensions(childS, 0, 1);
32700 ssSetOutputPortWidth(childS, 0, 1);
32701 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
32702 ssGetLocalBlockIO(rts))->Saturation8));
32703 }
32704 }
32705
32706 /* path info */
32707 _ssSetModelName(childS, "LagFilter_sf");
32708 _ssSetPath(childS,
32709 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/ lag filter2/Generated S-Function4");
32710 if (ssGetRTModel(rts) == (NULL)) {
32711 _ssSetParentSS(childS, rts);
32712 _ssSetRootSS(childS, ssGetRootSS(rts));
32713 } else {
32714 ssSetRTModel(childS,ssGetRTModel(rts));
32715 _ssSetParentSS(childS, (NULL));
32716 _ssSetRootSS(childS, childS);
32717 }
32718
32719 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
32720
32721 /* work vectors */
32722 {
32723 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
32724 (4 * sizeof(struct _ssDWorkRecord));
32725 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
32726 calloc(4, sizeof(struct _ssDWorkAuxRecord));
32727 ss_VALIDATE_MEMORY(rts,dWorkRecord);
32728 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
32729 ssSetSFcnDWork(childS, dWorkRecord);
32730 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
32731 _ssSetNumDWork(childS, 4);
32732
32733 /* DWORK0 */
32734 ssSetDWorkWidth(childS, 0, 1);
32735 ssSetDWorkDataType(childS, 0,SS_SINGLE);
32736 ssSetDWorkComplexSignal(childS, 0, 0);
32737 ssSetDWorkUsedAsDState(childS, 0, 1);
32738 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 241))[0]);
32739
32740 /* DWORK1 */
32741 ssSetDWorkWidth(childS, 1, 1);
32742 ssSetDWorkDataType(childS, 1,SS_SINGLE);
32743 ssSetDWorkComplexSignal(childS, 1, 0);
32744 ssSetDWorkUsedAsDState(childS, 1, 1);
32745 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 242))[0]);
32746
32747 /* DWORK2 */
32748 ssSetDWorkWidth(childS, 2, 1);
32749 ssSetDWorkDataType(childS, 2,SS_INT8);
32750 ssSetDWorkComplexSignal(childS, 2, 0);
32751 ssSetDWorkUsedAsDState(childS, 2, 1);
32752 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 469))[0]);
32753
32754 /* DWORK3 */
32755 ssSetDWorkWidth(childS, 3, 1);
32756 ssSetDWorkDataType(childS, 3,SS_INT8);
32757 ssSetDWorkComplexSignal(childS, 3, 0);
32758 ssSetDWorkUsedAsDState(childS, 3, 1);
32759 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 470))[0]);
32760 }
32761
32762 (childS)->regDataType.arg1 = ((void *)(childS));
32763 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
32764 FcnSetErrorStatus);
32765 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
32766 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
32767 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
32768 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
32769
32770 /* registration */
32771#if defined(MATLAB_MEX_FILE)
32772
32773 {
32774 int_T i;
32775 mxArray *plhs[1];
32776 mxArray *prhs[4];
32777 double *pr;
32778 volatile int_T *intS = (int_T *)&childS;
32779 int_T addrlen = sizeof(SimStruct *);
32780 int_T m = addrlen/sizeof(int_T) + 1;
32781 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
32782 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
32783 pr = mxGetPr(prhs[1]);
32784 for (i = 0; i < m - 1; i++) {
32785 pr[i] = (double)intS[i];
32786 }
32787
32788 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
32789 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
32790 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
32791
32792 /* Reset port dimensions info functions because the S-function
32793 * and accelerator mex-files explicitly set their dimensions,
32794 * i.e., they are not dynamically sized. For this case, the
32795 * mex-file is responsible for the dimensions info memory
32796 * and Simulink should not free it. This is achieved by
32797 * setting the following two methods to NULL.
32798 */
32799 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
32800 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
32801
32802 /*
32803 * Setup function pointers and call mdlInitializeSizes via
32804 * simulink.c
32805 */
32806 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
32807 mxDestroyArray(plhs[0]);
32808 mxDestroyArray(prhs[0]);
32809 mxDestroyArray(prhs[1]);
32810 mxDestroyArray(prhs[2]);
32811 mxDestroyArray(prhs[3]);
32812 }
32813
32814#else
32815
32816 {
32817 LagFilter_sf(childS);
32818 sfcnInitializeSizes(childS);
32819 }
32820
32821#endif
32822
32823 sfcnInitializeSampleTimes(childS);
32824
32825 /* adjust sample time */
32826 ssSetSampleTime(childS, 0, 0.0);
32827 ssSetOffsetTime(childS, 0, 0.0);
32828 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
32829
32830 /* set compiled values of dynamic vector attributes */
32831 ssSetNumNonsampledZCs(childS, 0);
32832
32833 /* Update connectivity flags for each port */
32834 _ssSetInputPortConnected(childS, 0, 1);
32835 _ssSetInputPortConnected(childS, 1, 1);
32836 _ssSetInputPortConnected(childS, 2, 1);
32837 _ssSetInputPortConnected(childS, 3, 1);
32838 _ssSetInputPortConnected(childS, 4, 1);
32839 _ssSetInputPortConnected(childS, 5, 1);
32840 _ssSetOutputPortConnected(childS, 0, 1);
32841 _ssSetOutputPortBeingMerged(childS, 0, 0);
32842
32843 /* Update the BufferDstPort flags for each input port */
32844 _ssSetInputPortBufferDstPort(childS, 0, -1);
32845 _ssSetInputPortBufferDstPort(childS, 1, -1);
32846 _ssSetInputPortBufferDstPort(childS, 2, -1);
32847 _ssSetInputPortBufferDstPort(childS, 3, -1);
32848 _ssSetInputPortBufferDstPort(childS, 4, -1);
32849 _ssSetInputPortBufferDstPort(childS, 5, -1);
32850 }
32851
32852 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S245>/Generated S-Function (Gain_sf) */
32853 {
32854 SimStruct *childS = ssGetSFunction(rts, 124);
32855
32856 /* timing info */
32857 time_T *sfcnPeriod;
32858 time_T *sfcnOffset;
32859 int_T *sfcnTsMap;
32860 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
32861 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
32862 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
32863 ss_VALIDATE_MEMORY(rts,sfcnOffset);
32864 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
32865 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
32866 (void) memset((void*)sfcnPeriod, 0,
32867 sizeof(time_T)*1);
32868 (void) memset((void*)sfcnOffset, 0,
32869 sizeof(time_T)*1);
32870 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
32871 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
32872 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
32873
32874 /* Set up the mdlInfo pointer */
32875# ifdef USE_RTMODEL
32876
32877 {
32878 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
32879 struct _ssBlkInfo2));
32880 ss_VALIDATE_MEMORY(rts,blkInfo2);
32881 ssSetBlkInfo2Ptr(childS, blkInfo2);
32882 }
32883
32884 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
32885
32886# else
32887
32888 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
32889
32890# endif /* USE_RTMODEL */
32891
32892 /* Allocate memory of model methods 2 */
32893 {
32894 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
32895 malloc(sizeof(struct _ssSFcnModelMethods2));
32896 ss_VALIDATE_MEMORY(rts,methods2);
32897 ssSetModelMethods2(childS, methods2);
32898 }
32899
32900 /* Allocate memory of model methods 3 */
32901 {
32902 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
32903 malloc(sizeof(struct _ssSFcnModelMethods3));
32904 ss_VALIDATE_MEMORY(rts,methods3);
32905 ssSetModelMethods3(childS, methods3);
32906 }
32907
32908 /* Allocate memory for states auxilliary information */
32909 {
32910 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
32911 (sizeof(struct _ssStatesInfo2));
32912 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
32913 malloc(sizeof(ssPeriodicStatesInfo));
32914 ss_VALIDATE_MEMORY(rts,statesInfo2);
32915 ssSetStatesInfo2(childS, statesInfo2);
32916 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
32917 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
32918 }
32919
32920 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
32921 RegNumInputPorts);
32922 ssSetRegNumInputPortsFcnArg(childS,childS);
32923
32924 /* inputs */
32925 {
32926 struct _ssPortInputs *inputPortInfo =
32927 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
32928 ss_VALIDATE_MEMORY(rts,inputPortInfo);
32929 _ssSetNumInputPorts(childS, 2);
32930 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
32931
32932 /* port 0 */
32933 {
32934 real32_T const **sfcnUPtrs = (real32_T const **)
32935 malloc(1 * sizeof(real32_T *));
32936 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32937 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32938 ssGetLocalBlockIO(rts))->Sum_ot;
32939 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
32940 _ssSetInputPortNumDimensions(childS, 0, 1);
32941 ssSetInputPortWidth(childS, 0, 1);
32942 }
32943
32944 /* port 1 */
32945 {
32946 real32_T const **sfcnUPtrs = (real32_T const **)
32947 malloc(1 * sizeof(real32_T *));
32948 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
32949 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
32950 ssGetLocalBlockIO(rts))->Product_pf;
32951 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
32952 _ssSetInputPortNumDimensions(childS, 1, 1);
32953 ssSetInputPortWidth(childS, 1, 1);
32954 }
32955 }
32956
32957 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
32958 RegNumOutputPorts);
32959 ssSetRegNumOutputPortsFcnArg(childS,childS);
32960
32961 /* outputs */
32962 {
32963 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
32964 calloc(1, sizeof(struct _ssPortOutputs));
32965 ss_VALIDATE_MEMORY(rts,outputPortInfo);
32966 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
32967 _ssSetNumOutputPorts(childS, 1);
32968
32969 /* port 0 */
32970 {
32971 _ssSetOutputPortNumDimensions(childS, 0, 1);
32972 ssSetOutputPortWidth(childS, 0, 1);
32973 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
32974 ssGetLocalBlockIO(rts))->GeneratedSFunction_fe));
32975 }
32976 }
32977
32978 /* path info */
32979 _ssSetModelName(childS, "Gain_sf");
32980 _ssSetPath(childS,
32981 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain3/Generated S-Function");
32982 if (ssGetRTModel(rts) == (NULL)) {
32983 _ssSetParentSS(childS, rts);
32984 _ssSetRootSS(childS, ssGetRootSS(rts));
32985 } else {
32986 ssSetRTModel(childS,ssGetRTModel(rts));
32987 _ssSetParentSS(childS, (NULL));
32988 _ssSetRootSS(childS, childS);
32989 }
32990
32991 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
32992 (childS)->regDataType.arg1 = ((void *)(childS));
32993 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
32994 FcnSetErrorStatus);
32995 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
32996 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
32997 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
32998 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
32999
33000 /* registration */
33001#if defined(MATLAB_MEX_FILE)
33002
33003 {
33004 int_T i;
33005 mxArray *plhs[1];
33006 mxArray *prhs[4];
33007 double *pr;
33008 volatile int_T *intS = (int_T *)&childS;
33009 int_T addrlen = sizeof(SimStruct *);
33010 int_T m = addrlen/sizeof(int_T) + 1;
33011 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
33012 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
33013 pr = mxGetPr(prhs[1]);
33014 for (i = 0; i < m - 1; i++) {
33015 pr[i] = (double)intS[i];
33016 }
33017
33018 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
33019 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
33020 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
33021
33022 /* Reset port dimensions info functions because the S-function
33023 * and accelerator mex-files explicitly set their dimensions,
33024 * i.e., they are not dynamically sized. For this case, the
33025 * mex-file is responsible for the dimensions info memory
33026 * and Simulink should not free it. This is achieved by
33027 * setting the following two methods to NULL.
33028 */
33029 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
33030 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
33031
33032 /*
33033 * Setup function pointers and call mdlInitializeSizes via
33034 * simulink.c
33035 */
33036 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
33037 mxDestroyArray(plhs[0]);
33038 mxDestroyArray(prhs[0]);
33039 mxDestroyArray(prhs[1]);
33040 mxDestroyArray(prhs[2]);
33041 mxDestroyArray(prhs[3]);
33042 }
33043
33044#else
33045
33046 {
33047 Gain_sf(childS);
33048 sfcnInitializeSizes(childS);
33049 }
33050
33051#endif
33052
33053 sfcnInitializeSampleTimes(childS);
33054
33055 /* adjust sample time */
33056 ssSetSampleTime(childS, 0, 0.0);
33057 ssSetOffsetTime(childS, 0, 0.0);
33058 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
33059
33060 /* set compiled values of dynamic vector attributes */
33061 ssSetNumNonsampledZCs(childS, 0);
33062
33063 /* Update connectivity flags for each port */
33064 _ssSetInputPortConnected(childS, 0, 1);
33065 _ssSetInputPortConnected(childS, 1, 1);
33066 _ssSetOutputPortConnected(childS, 0, 1);
33067 _ssSetOutputPortBeingMerged(childS, 0, 0);
33068
33069 /* Update the BufferDstPort flags for each input port */
33070 _ssSetInputPortBufferDstPort(childS, 0, -1);
33071 _ssSetInputPortBufferDstPort(childS, 1, -1);
33072 }
33073
33074 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S246>/Generated S-Function (Gain_sf) */
33075 {
33076 SimStruct *childS = ssGetSFunction(rts, 125);
33077
33078 /* timing info */
33079 time_T *sfcnPeriod;
33080 time_T *sfcnOffset;
33081 int_T *sfcnTsMap;
33082 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
33083 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
33084 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
33085 ss_VALIDATE_MEMORY(rts,sfcnOffset);
33086 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
33087 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
33088 (void) memset((void*)sfcnPeriod, 0,
33089 sizeof(time_T)*1);
33090 (void) memset((void*)sfcnOffset, 0,
33091 sizeof(time_T)*1);
33092 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
33093 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
33094 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
33095
33096 /* Set up the mdlInfo pointer */
33097# ifdef USE_RTMODEL
33098
33099 {
33100 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
33101 struct _ssBlkInfo2));
33102 ss_VALIDATE_MEMORY(rts,blkInfo2);
33103 ssSetBlkInfo2Ptr(childS, blkInfo2);
33104 }
33105
33106 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
33107
33108# else
33109
33110 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
33111
33112# endif /* USE_RTMODEL */
33113
33114 /* Allocate memory of model methods 2 */
33115 {
33116 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
33117 malloc(sizeof(struct _ssSFcnModelMethods2));
33118 ss_VALIDATE_MEMORY(rts,methods2);
33119 ssSetModelMethods2(childS, methods2);
33120 }
33121
33122 /* Allocate memory of model methods 3 */
33123 {
33124 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
33125 malloc(sizeof(struct _ssSFcnModelMethods3));
33126 ss_VALIDATE_MEMORY(rts,methods3);
33127 ssSetModelMethods3(childS, methods3);
33128 }
33129
33130 /* Allocate memory for states auxilliary information */
33131 {
33132 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
33133 (sizeof(struct _ssStatesInfo2));
33134 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
33135 malloc(sizeof(ssPeriodicStatesInfo));
33136 ss_VALIDATE_MEMORY(rts,statesInfo2);
33137 ssSetStatesInfo2(childS, statesInfo2);
33138 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
33139 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
33140 }
33141
33142 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
33143 RegNumInputPorts);
33144 ssSetRegNumInputPortsFcnArg(childS,childS);
33145
33146 /* inputs */
33147 {
33148 struct _ssPortInputs *inputPortInfo =
33149 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
33150 ss_VALIDATE_MEMORY(rts,inputPortInfo);
33151 _ssSetNumInputPorts(childS, 2);
33152 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
33153
33154 /* port 0 */
33155 {
33156 real32_T const **sfcnUPtrs = (real32_T const **)
33157 malloc(1 * sizeof(real32_T *));
33158 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33159 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33160 ssGetLocalBlockIO(rts))->GeneratedSFunction_fe;
33161 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
33162 _ssSetInputPortNumDimensions(childS, 0, 1);
33163 ssSetInputPortWidth(childS, 0, 1);
33164 }
33165
33166 /* port 1 */
33167 {
33168 real32_T const **sfcnUPtrs = (real32_T const **)
33169 malloc(1 * sizeof(real32_T *));
33170 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33171 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
33172 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
33173 _ssSetInputPortNumDimensions(childS, 1, 1);
33174 ssSetInputPortWidth(childS, 1, 1);
33175 }
33176 }
33177
33178 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
33179 RegNumOutputPorts);
33180 ssSetRegNumOutputPortsFcnArg(childS,childS);
33181
33182 /* outputs */
33183 {
33184 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
33185 calloc(1, sizeof(struct _ssPortOutputs));
33186 ss_VALIDATE_MEMORY(rts,outputPortInfo);
33187 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
33188 _ssSetNumOutputPorts(childS, 1);
33189
33190 /* port 0 */
33191 {
33192 _ssSetOutputPortNumDimensions(childS, 0, 1);
33193 ssSetOutputPortWidth(childS, 0, 1);
33194 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
33195 ssGetLocalBlockIO(rts))->GeneratedSFunction_gq));
33196 }
33197 }
33198
33199 /* path info */
33200 _ssSetModelName(childS, "Gain_sf");
33201 _ssSetPath(childS,
33202 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain4/Generated S-Function");
33203 if (ssGetRTModel(rts) == (NULL)) {
33204 _ssSetParentSS(childS, rts);
33205 _ssSetRootSS(childS, ssGetRootSS(rts));
33206 } else {
33207 ssSetRTModel(childS,ssGetRTModel(rts));
33208 _ssSetParentSS(childS, (NULL));
33209 _ssSetRootSS(childS, childS);
33210 }
33211
33212 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
33213 (childS)->regDataType.arg1 = ((void *)(childS));
33214 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
33215 FcnSetErrorStatus);
33216 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
33217 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
33218 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
33219 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
33220
33221 /* registration */
33222#if defined(MATLAB_MEX_FILE)
33223
33224 {
33225 int_T i;
33226 mxArray *plhs[1];
33227 mxArray *prhs[4];
33228 double *pr;
33229 volatile int_T *intS = (int_T *)&childS;
33230 int_T addrlen = sizeof(SimStruct *);
33231 int_T m = addrlen/sizeof(int_T) + 1;
33232 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
33233 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
33234 pr = mxGetPr(prhs[1]);
33235 for (i = 0; i < m - 1; i++) {
33236 pr[i] = (double)intS[i];
33237 }
33238
33239 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
33240 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
33241 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
33242
33243 /* Reset port dimensions info functions because the S-function
33244 * and accelerator mex-files explicitly set their dimensions,
33245 * i.e., they are not dynamically sized. For this case, the
33246 * mex-file is responsible for the dimensions info memory
33247 * and Simulink should not free it. This is achieved by
33248 * setting the following two methods to NULL.
33249 */
33250 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
33251 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
33252
33253 /*
33254 * Setup function pointers and call mdlInitializeSizes via
33255 * simulink.c
33256 */
33257 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
33258 mxDestroyArray(plhs[0]);
33259 mxDestroyArray(prhs[0]);
33260 mxDestroyArray(prhs[1]);
33261 mxDestroyArray(prhs[2]);
33262 mxDestroyArray(prhs[3]);
33263 }
33264
33265#else
33266
33267 {
33268 Gain_sf(childS);
33269 sfcnInitializeSizes(childS);
33270 }
33271
33272#endif
33273
33274 sfcnInitializeSampleTimes(childS);
33275
33276 /* adjust sample time */
33277 ssSetSampleTime(childS, 0, 0.0);
33278 ssSetOffsetTime(childS, 0, 0.0);
33279 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
33280
33281 /* set compiled values of dynamic vector attributes */
33282 ssSetNumNonsampledZCs(childS, 0);
33283
33284 /* Update connectivity flags for each port */
33285 _ssSetInputPortConnected(childS, 0, 1);
33286 _ssSetInputPortConnected(childS, 1, 1);
33287 _ssSetOutputPortConnected(childS, 0, 1);
33288 _ssSetOutputPortBeingMerged(childS, 0, 0);
33289
33290 /* Update the BufferDstPort flags for each input port */
33291 _ssSetInputPortBufferDstPort(childS, 0, -1);
33292 _ssSetInputPortBufferDstPort(childS, 1, -1);
33293 }
33294
33295 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S239>/Generated S-Function4 (LagFilter_sf) */
33296 {
33297 SimStruct *childS = ssGetSFunction(rts, 126);
33298
33299 /* timing info */
33300 time_T *sfcnPeriod;
33301 time_T *sfcnOffset;
33302 int_T *sfcnTsMap;
33303 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
33304 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
33305 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
33306 ss_VALIDATE_MEMORY(rts,sfcnOffset);
33307 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
33308 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
33309 (void) memset((void*)sfcnPeriod, 0,
33310 sizeof(time_T)*1);
33311 (void) memset((void*)sfcnOffset, 0,
33312 sizeof(time_T)*1);
33313 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
33314 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
33315 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
33316
33317 /* Set up the mdlInfo pointer */
33318# ifdef USE_RTMODEL
33319
33320 {
33321 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
33322 struct _ssBlkInfo2));
33323 ss_VALIDATE_MEMORY(rts,blkInfo2);
33324 ssSetBlkInfo2Ptr(childS, blkInfo2);
33325 }
33326
33327 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
33328
33329# else
33330
33331 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
33332
33333# endif /* USE_RTMODEL */
33334
33335 /* Allocate memory of model methods 2 */
33336 {
33337 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
33338 malloc(sizeof(struct _ssSFcnModelMethods2));
33339 ss_VALIDATE_MEMORY(rts,methods2);
33340 ssSetModelMethods2(childS, methods2);
33341 }
33342
33343 /* Allocate memory of model methods 3 */
33344 {
33345 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
33346 malloc(sizeof(struct _ssSFcnModelMethods3));
33347 ss_VALIDATE_MEMORY(rts,methods3);
33348 ssSetModelMethods3(childS, methods3);
33349 }
33350
33351 /* Allocate memory for states auxilliary information */
33352 {
33353 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
33354 (sizeof(struct _ssStatesInfo2));
33355 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
33356 malloc(sizeof(ssPeriodicStatesInfo));
33357 ss_VALIDATE_MEMORY(rts,statesInfo2);
33358 ssSetStatesInfo2(childS, statesInfo2);
33359 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
33360 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
33361 }
33362
33363 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
33364 RegNumInputPorts);
33365 ssSetRegNumInputPortsFcnArg(childS,childS);
33366
33367 /* inputs */
33368 {
33369 struct _ssPortInputs *inputPortInfo =
33370 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
33371 ss_VALIDATE_MEMORY(rts,inputPortInfo);
33372 _ssSetNumInputPorts(childS, 6);
33373 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
33374
33375 /* port 0 */
33376 {
33377 real32_T const **sfcnUPtrs = (real32_T const **)
33378 malloc(1 * sizeof(real32_T *));
33379 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33380 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33381 ssGetLocalBlockIO(rts))->dtCAS;
33382 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
33383 _ssSetInputPortNumDimensions(childS, 0, 1);
33384 ssSetInputPortWidth(childS, 0, 1);
33385 }
33386
33387 /* port 1 */
33388 {
33389 int8_T const **sfcnUPtrs = (int8_T const **)
33390 malloc(1 * sizeof(int8_T *));
33391 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33392 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
33393 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
33394 _ssSetInputPortNumDimensions(childS, 1, 1);
33395 ssSetInputPortWidth(childS, 1, 1);
33396 }
33397
33398 /* port 2 */
33399 {
33400 real32_T const **sfcnUPtrs = (real32_T const **)
33401 malloc(1 * sizeof(real32_T *));
33402 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33403 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
33404 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
33405 _ssSetInputPortNumDimensions(childS, 2, 1);
33406 ssSetInputPortWidth(childS, 2, 1);
33407 }
33408
33409 /* port 3 */
33410 {
33411 real32_T const **sfcnUPtrs = (real32_T const **)
33412 malloc(1 * sizeof(real32_T *));
33413 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33414 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33415 ssGetLocalBlockIO(rts))->Ny;
33416 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
33417 _ssSetInputPortNumDimensions(childS, 3, 1);
33418 ssSetInputPortWidth(childS, 3, 1);
33419 }
33420
33421 /* port 4 */
33422 {
33423 real32_T const **sfcnUPtrs = (real32_T const **)
33424 malloc(1 * sizeof(real32_T *));
33425 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33426 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33427 ssGetLocalBlockIO(rts))->Ny;
33428 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
33429 _ssSetInputPortNumDimensions(childS, 4, 1);
33430 ssSetInputPortWidth(childS, 4, 1);
33431 }
33432
33433 /* port 5 */
33434 {
33435 real32_T const **sfcnUPtrs = (real32_T const **)
33436 malloc(1 * sizeof(real32_T *));
33437 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33438 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33439 ssGetLocalBlockIO(rts))->Ny;
33440 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
33441 _ssSetInputPortNumDimensions(childS, 5, 1);
33442 ssSetInputPortWidth(childS, 5, 1);
33443 }
33444 }
33445
33446 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
33447 RegNumOutputPorts);
33448 ssSetRegNumOutputPortsFcnArg(childS,childS);
33449
33450 /* outputs */
33451 {
33452 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
33453 calloc(1, sizeof(struct _ssPortOutputs));
33454 ss_VALIDATE_MEMORY(rts,outputPortInfo);
33455 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
33456 _ssSetNumOutputPorts(childS, 1);
33457
33458 /* port 0 */
33459 {
33460 _ssSetOutputPortNumDimensions(childS, 0, 1);
33461 ssSetOutputPortWidth(childS, 0, 1);
33462 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
33463 ssGetLocalBlockIO(rts))->GeneratedSFunction4_kq));
33464 }
33465 }
33466
33467 /* path info */
33468 _ssSetModelName(childS, "LagFilter_sf");
33469 _ssSetPath(childS,
33470 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/ lag filter/Generated S-Function4");
33471 if (ssGetRTModel(rts) == (NULL)) {
33472 _ssSetParentSS(childS, rts);
33473 _ssSetRootSS(childS, ssGetRootSS(rts));
33474 } else {
33475 ssSetRTModel(childS,ssGetRTModel(rts));
33476 _ssSetParentSS(childS, (NULL));
33477 _ssSetRootSS(childS, childS);
33478 }
33479
33480 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
33481
33482 /* work vectors */
33483 {
33484 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
33485 (4 * sizeof(struct _ssDWorkRecord));
33486 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
33487 calloc(4, sizeof(struct _ssDWorkAuxRecord));
33488 ss_VALIDATE_MEMORY(rts,dWorkRecord);
33489 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
33490 ssSetSFcnDWork(childS, dWorkRecord);
33491 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
33492 _ssSetNumDWork(childS, 4);
33493
33494 /* DWORK0 */
33495 ssSetDWorkWidth(childS, 0, 1);
33496 ssSetDWorkDataType(childS, 0,SS_SINGLE);
33497 ssSetDWorkComplexSignal(childS, 0, 0);
33498 ssSetDWorkUsedAsDState(childS, 0, 1);
33499 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 243))[0]);
33500
33501 /* DWORK1 */
33502 ssSetDWorkWidth(childS, 1, 1);
33503 ssSetDWorkDataType(childS, 1,SS_SINGLE);
33504 ssSetDWorkComplexSignal(childS, 1, 0);
33505 ssSetDWorkUsedAsDState(childS, 1, 1);
33506 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 244))[0]);
33507
33508 /* DWORK2 */
33509 ssSetDWorkWidth(childS, 2, 1);
33510 ssSetDWorkDataType(childS, 2,SS_INT8);
33511 ssSetDWorkComplexSignal(childS, 2, 0);
33512 ssSetDWorkUsedAsDState(childS, 2, 1);
33513 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 471))[0]);
33514
33515 /* DWORK3 */
33516 ssSetDWorkWidth(childS, 3, 1);
33517 ssSetDWorkDataType(childS, 3,SS_INT8);
33518 ssSetDWorkComplexSignal(childS, 3, 0);
33519 ssSetDWorkUsedAsDState(childS, 3, 1);
33520 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 472))[0]);
33521 }
33522
33523 (childS)->regDataType.arg1 = ((void *)(childS));
33524 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
33525 FcnSetErrorStatus);
33526 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
33527 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
33528 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
33529 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
33530
33531 /* registration */
33532#if defined(MATLAB_MEX_FILE)
33533
33534 {
33535 int_T i;
33536 mxArray *plhs[1];
33537 mxArray *prhs[4];
33538 double *pr;
33539 volatile int_T *intS = (int_T *)&childS;
33540 int_T addrlen = sizeof(SimStruct *);
33541 int_T m = addrlen/sizeof(int_T) + 1;
33542 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
33543 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
33544 pr = mxGetPr(prhs[1]);
33545 for (i = 0; i < m - 1; i++) {
33546 pr[i] = (double)intS[i];
33547 }
33548
33549 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
33550 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
33551 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
33552
33553 /* Reset port dimensions info functions because the S-function
33554 * and accelerator mex-files explicitly set their dimensions,
33555 * i.e., they are not dynamically sized. For this case, the
33556 * mex-file is responsible for the dimensions info memory
33557 * and Simulink should not free it. This is achieved by
33558 * setting the following two methods to NULL.
33559 */
33560 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
33561 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
33562
33563 /*
33564 * Setup function pointers and call mdlInitializeSizes via
33565 * simulink.c
33566 */
33567 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
33568 mxDestroyArray(plhs[0]);
33569 mxDestroyArray(prhs[0]);
33570 mxDestroyArray(prhs[1]);
33571 mxDestroyArray(prhs[2]);
33572 mxDestroyArray(prhs[3]);
33573 }
33574
33575#else
33576
33577 {
33578 LagFilter_sf(childS);
33579 sfcnInitializeSizes(childS);
33580 }
33581
33582#endif
33583
33584 sfcnInitializeSampleTimes(childS);
33585
33586 /* adjust sample time */
33587 ssSetSampleTime(childS, 0, 0.0);
33588 ssSetOffsetTime(childS, 0, 0.0);
33589 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
33590
33591 /* set compiled values of dynamic vector attributes */
33592 ssSetNumNonsampledZCs(childS, 0);
33593
33594 /* Update connectivity flags for each port */
33595 _ssSetInputPortConnected(childS, 0, 1);
33596 _ssSetInputPortConnected(childS, 1, 1);
33597 _ssSetInputPortConnected(childS, 2, 1);
33598 _ssSetInputPortConnected(childS, 3, 1);
33599 _ssSetInputPortConnected(childS, 4, 1);
33600 _ssSetInputPortConnected(childS, 5, 1);
33601 _ssSetOutputPortConnected(childS, 0, 1);
33602 _ssSetOutputPortBeingMerged(childS, 0, 0);
33603
33604 /* Update the BufferDstPort flags for each input port */
33605 _ssSetInputPortBufferDstPort(childS, 0, -1);
33606 _ssSetInputPortBufferDstPort(childS, 1, -1);
33607 _ssSetInputPortBufferDstPort(childS, 2, -1);
33608 _ssSetInputPortBufferDstPort(childS, 3, -1);
33609 _ssSetInputPortBufferDstPort(childS, 4, -1);
33610 _ssSetInputPortBufferDstPort(childS, 5, -1);
33611 }
33612
33613 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S242>/Generated S-Function (Gain_sf) */
33614 {
33615 SimStruct *childS = ssGetSFunction(rts, 127);
33616
33617 /* timing info */
33618 time_T *sfcnPeriod;
33619 time_T *sfcnOffset;
33620 int_T *sfcnTsMap;
33621 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
33622 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
33623 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
33624 ss_VALIDATE_MEMORY(rts,sfcnOffset);
33625 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
33626 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
33627 (void) memset((void*)sfcnPeriod, 0,
33628 sizeof(time_T)*1);
33629 (void) memset((void*)sfcnOffset, 0,
33630 sizeof(time_T)*1);
33631 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
33632 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
33633 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
33634
33635 /* Set up the mdlInfo pointer */
33636# ifdef USE_RTMODEL
33637
33638 {
33639 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
33640 struct _ssBlkInfo2));
33641 ss_VALIDATE_MEMORY(rts,blkInfo2);
33642 ssSetBlkInfo2Ptr(childS, blkInfo2);
33643 }
33644
33645 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
33646
33647# else
33648
33649 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
33650
33651# endif /* USE_RTMODEL */
33652
33653 /* Allocate memory of model methods 2 */
33654 {
33655 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
33656 malloc(sizeof(struct _ssSFcnModelMethods2));
33657 ss_VALIDATE_MEMORY(rts,methods2);
33658 ssSetModelMethods2(childS, methods2);
33659 }
33660
33661 /* Allocate memory of model methods 3 */
33662 {
33663 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
33664 malloc(sizeof(struct _ssSFcnModelMethods3));
33665 ss_VALIDATE_MEMORY(rts,methods3);
33666 ssSetModelMethods3(childS, methods3);
33667 }
33668
33669 /* Allocate memory for states auxilliary information */
33670 {
33671 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
33672 (sizeof(struct _ssStatesInfo2));
33673 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
33674 malloc(sizeof(ssPeriodicStatesInfo));
33675 ss_VALIDATE_MEMORY(rts,statesInfo2);
33676 ssSetStatesInfo2(childS, statesInfo2);
33677 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
33678 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
33679 }
33680
33681 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
33682 RegNumInputPorts);
33683 ssSetRegNumInputPortsFcnArg(childS,childS);
33684
33685 /* inputs */
33686 {
33687 struct _ssPortInputs *inputPortInfo =
33688 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
33689 ss_VALIDATE_MEMORY(rts,inputPortInfo);
33690 _ssSetNumInputPorts(childS, 2);
33691 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
33692
33693 /* port 0 */
33694 {
33695 real32_T const **sfcnUPtrs = (real32_T const **)
33696 malloc(1 * sizeof(real32_T *));
33697 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33698 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33699 ssGetLocalBlockIO(rts))->GeneratedSFunction4_kq;
33700 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
33701 _ssSetInputPortNumDimensions(childS, 0, 1);
33702 ssSetInputPortWidth(childS, 0, 1);
33703 }
33704
33705 /* port 1 */
33706 {
33707 real32_T const **sfcnUPtrs = (real32_T const **)
33708 malloc(1 * sizeof(real32_T *));
33709 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33710 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled108;
33711 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
33712 _ssSetInputPortNumDimensions(childS, 1, 1);
33713 ssSetInputPortWidth(childS, 1, 1);
33714 }
33715 }
33716
33717 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
33718 RegNumOutputPorts);
33719 ssSetRegNumOutputPortsFcnArg(childS,childS);
33720
33721 /* outputs */
33722 {
33723 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
33724 calloc(1, sizeof(struct _ssPortOutputs));
33725 ss_VALIDATE_MEMORY(rts,outputPortInfo);
33726 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
33727 _ssSetNumOutputPorts(childS, 1);
33728
33729 /* port 0 */
33730 {
33731 _ssSetOutputPortNumDimensions(childS, 0, 1);
33732 ssSetOutputPortWidth(childS, 0, 1);
33733 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
33734 ssGetLocalBlockIO(rts))->Saturation8));
33735 }
33736 }
33737
33738 /* path info */
33739 _ssSetModelName(childS, "Gain_sf");
33740 _ssSetPath(childS,
33741 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain/Generated S-Function");
33742 if (ssGetRTModel(rts) == (NULL)) {
33743 _ssSetParentSS(childS, rts);
33744 _ssSetRootSS(childS, ssGetRootSS(rts));
33745 } else {
33746 ssSetRTModel(childS,ssGetRTModel(rts));
33747 _ssSetParentSS(childS, (NULL));
33748 _ssSetRootSS(childS, childS);
33749 }
33750
33751 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
33752 (childS)->regDataType.arg1 = ((void *)(childS));
33753 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
33754 FcnSetErrorStatus);
33755 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
33756 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
33757 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
33758 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
33759
33760 /* registration */
33761#if defined(MATLAB_MEX_FILE)
33762
33763 {
33764 int_T i;
33765 mxArray *plhs[1];
33766 mxArray *prhs[4];
33767 double *pr;
33768 volatile int_T *intS = (int_T *)&childS;
33769 int_T addrlen = sizeof(SimStruct *);
33770 int_T m = addrlen/sizeof(int_T) + 1;
33771 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
33772 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
33773 pr = mxGetPr(prhs[1]);
33774 for (i = 0; i < m - 1; i++) {
33775 pr[i] = (double)intS[i];
33776 }
33777
33778 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
33779 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
33780 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
33781
33782 /* Reset port dimensions info functions because the S-function
33783 * and accelerator mex-files explicitly set their dimensions,
33784 * i.e., they are not dynamically sized. For this case, the
33785 * mex-file is responsible for the dimensions info memory
33786 * and Simulink should not free it. This is achieved by
33787 * setting the following two methods to NULL.
33788 */
33789 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
33790 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
33791
33792 /*
33793 * Setup function pointers and call mdlInitializeSizes via
33794 * simulink.c
33795 */
33796 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
33797 mxDestroyArray(plhs[0]);
33798 mxDestroyArray(prhs[0]);
33799 mxDestroyArray(prhs[1]);
33800 mxDestroyArray(prhs[2]);
33801 mxDestroyArray(prhs[3]);
33802 }
33803
33804#else
33805
33806 {
33807 Gain_sf(childS);
33808 sfcnInitializeSizes(childS);
33809 }
33810
33811#endif
33812
33813 sfcnInitializeSampleTimes(childS);
33814
33815 /* adjust sample time */
33816 ssSetSampleTime(childS, 0, 0.0);
33817 ssSetOffsetTime(childS, 0, 0.0);
33818 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
33819
33820 /* set compiled values of dynamic vector attributes */
33821 ssSetNumNonsampledZCs(childS, 0);
33822
33823 /* Update connectivity flags for each port */
33824 _ssSetInputPortConnected(childS, 0, 1);
33825 _ssSetInputPortConnected(childS, 1, 1);
33826 _ssSetOutputPortConnected(childS, 0, 1);
33827 _ssSetOutputPortBeingMerged(childS, 0, 0);
33828
33829 /* Update the BufferDstPort flags for each input port */
33830 _ssSetInputPortBufferDstPort(childS, 0, -1);
33831 _ssSetInputPortBufferDstPort(childS, 1, -1);
33832 }
33833
33834 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S240>/Generated S-Function4 (LagFilter_sf) */
33835 {
33836 SimStruct *childS = ssGetSFunction(rts, 128);
33837
33838 /* timing info */
33839 time_T *sfcnPeriod;
33840 time_T *sfcnOffset;
33841 int_T *sfcnTsMap;
33842 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
33843 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
33844 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
33845 ss_VALIDATE_MEMORY(rts,sfcnOffset);
33846 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
33847 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
33848 (void) memset((void*)sfcnPeriod, 0,
33849 sizeof(time_T)*1);
33850 (void) memset((void*)sfcnOffset, 0,
33851 sizeof(time_T)*1);
33852 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
33853 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
33854 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
33855
33856 /* Set up the mdlInfo pointer */
33857# ifdef USE_RTMODEL
33858
33859 {
33860 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
33861 struct _ssBlkInfo2));
33862 ss_VALIDATE_MEMORY(rts,blkInfo2);
33863 ssSetBlkInfo2Ptr(childS, blkInfo2);
33864 }
33865
33866 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
33867
33868# else
33869
33870 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
33871
33872# endif /* USE_RTMODEL */
33873
33874 /* Allocate memory of model methods 2 */
33875 {
33876 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
33877 malloc(sizeof(struct _ssSFcnModelMethods2));
33878 ss_VALIDATE_MEMORY(rts,methods2);
33879 ssSetModelMethods2(childS, methods2);
33880 }
33881
33882 /* Allocate memory of model methods 3 */
33883 {
33884 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
33885 malloc(sizeof(struct _ssSFcnModelMethods3));
33886 ss_VALIDATE_MEMORY(rts,methods3);
33887 ssSetModelMethods3(childS, methods3);
33888 }
33889
33890 /* Allocate memory for states auxilliary information */
33891 {
33892 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
33893 (sizeof(struct _ssStatesInfo2));
33894 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
33895 malloc(sizeof(ssPeriodicStatesInfo));
33896 ss_VALIDATE_MEMORY(rts,statesInfo2);
33897 ssSetStatesInfo2(childS, statesInfo2);
33898 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
33899 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
33900 }
33901
33902 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
33903 RegNumInputPorts);
33904 ssSetRegNumInputPortsFcnArg(childS,childS);
33905
33906 /* inputs */
33907 {
33908 struct _ssPortInputs *inputPortInfo =
33909 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
33910 ss_VALIDATE_MEMORY(rts,inputPortInfo);
33911 _ssSetNumInputPorts(childS, 6);
33912 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
33913
33914 /* port 0 */
33915 {
33916 real32_T const **sfcnUPtrs = (real32_T const **)
33917 malloc(1 * sizeof(real32_T *));
33918 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33919 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33920 ssGetLocalBlockIO(rts))->dtCAS;
33921 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
33922 _ssSetInputPortNumDimensions(childS, 0, 1);
33923 ssSetInputPortWidth(childS, 0, 1);
33924 }
33925
33926 /* port 1 */
33927 {
33928 int8_T const **sfcnUPtrs = (int8_T const **)
33929 malloc(1 * sizeof(int8_T *));
33930 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33931 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
33932 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
33933 _ssSetInputPortNumDimensions(childS, 1, 1);
33934 ssSetInputPortWidth(childS, 1, 1);
33935 }
33936
33937 /* port 2 */
33938 {
33939 real32_T const **sfcnUPtrs = (real32_T const **)
33940 malloc(1 * sizeof(real32_T *));
33941 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33942 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled126;
33943 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
33944 _ssSetInputPortNumDimensions(childS, 2, 1);
33945 ssSetInputPortWidth(childS, 2, 1);
33946 }
33947
33948 /* port 3 */
33949 {
33950 real32_T const **sfcnUPtrs = (real32_T const **)
33951 malloc(1 * sizeof(real32_T *));
33952 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33953 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33954 ssGetLocalBlockIO(rts))->Saturation1_o;
33955 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
33956 _ssSetInputPortNumDimensions(childS, 3, 1);
33957 ssSetInputPortWidth(childS, 3, 1);
33958 }
33959
33960 /* port 4 */
33961 {
33962 real32_T const **sfcnUPtrs = (real32_T const **)
33963 malloc(1 * sizeof(real32_T *));
33964 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33965 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33966 ssGetLocalBlockIO(rts))->Saturation1_o;
33967 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
33968 _ssSetInputPortNumDimensions(childS, 4, 1);
33969 ssSetInputPortWidth(childS, 4, 1);
33970 }
33971
33972 /* port 5 */
33973 {
33974 real32_T const **sfcnUPtrs = (real32_T const **)
33975 malloc(1 * sizeof(real32_T *));
33976 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
33977 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
33978 ssGetLocalBlockIO(rts))->Saturation1_o;
33979 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
33980 _ssSetInputPortNumDimensions(childS, 5, 1);
33981 ssSetInputPortWidth(childS, 5, 1);
33982 }
33983 }
33984
33985 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
33986 RegNumOutputPorts);
33987 ssSetRegNumOutputPortsFcnArg(childS,childS);
33988
33989 /* outputs */
33990 {
33991 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
33992 calloc(1, sizeof(struct _ssPortOutputs));
33993 ss_VALIDATE_MEMORY(rts,outputPortInfo);
33994 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
33995 _ssSetNumOutputPorts(childS, 1);
33996
33997 /* port 0 */
33998 {
33999 _ssSetOutputPortNumDimensions(childS, 0, 1);
34000 ssSetOutputPortWidth(childS, 0, 1);
34001 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
34002 ssGetLocalBlockIO(rts))->GeneratedSFunction4_ab));
34003 }
34004 }
34005
34006 /* path info */
34007 _ssSetModelName(childS, "LagFilter_sf");
34008 _ssSetPath(childS,
34009 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/ lag filter1/Generated S-Function4");
34010 if (ssGetRTModel(rts) == (NULL)) {
34011 _ssSetParentSS(childS, rts);
34012 _ssSetRootSS(childS, ssGetRootSS(rts));
34013 } else {
34014 ssSetRTModel(childS,ssGetRTModel(rts));
34015 _ssSetParentSS(childS, (NULL));
34016 _ssSetRootSS(childS, childS);
34017 }
34018
34019 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
34020
34021 /* work vectors */
34022 {
34023 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
34024 (4 * sizeof(struct _ssDWorkRecord));
34025 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
34026 calloc(4, sizeof(struct _ssDWorkAuxRecord));
34027 ss_VALIDATE_MEMORY(rts,dWorkRecord);
34028 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
34029 ssSetSFcnDWork(childS, dWorkRecord);
34030 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
34031 _ssSetNumDWork(childS, 4);
34032
34033 /* DWORK0 */
34034 ssSetDWorkWidth(childS, 0, 1);
34035 ssSetDWorkDataType(childS, 0,SS_SINGLE);
34036 ssSetDWorkComplexSignal(childS, 0, 0);
34037 ssSetDWorkUsedAsDState(childS, 0, 1);
34038 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 245))[0]);
34039
34040 /* DWORK1 */
34041 ssSetDWorkWidth(childS, 1, 1);
34042 ssSetDWorkDataType(childS, 1,SS_SINGLE);
34043 ssSetDWorkComplexSignal(childS, 1, 0);
34044 ssSetDWorkUsedAsDState(childS, 1, 1);
34045 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 246))[0]);
34046
34047 /* DWORK2 */
34048 ssSetDWorkWidth(childS, 2, 1);
34049 ssSetDWorkDataType(childS, 2,SS_INT8);
34050 ssSetDWorkComplexSignal(childS, 2, 0);
34051 ssSetDWorkUsedAsDState(childS, 2, 1);
34052 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 473))[0]);
34053
34054 /* DWORK3 */
34055 ssSetDWorkWidth(childS, 3, 1);
34056 ssSetDWorkDataType(childS, 3,SS_INT8);
34057 ssSetDWorkComplexSignal(childS, 3, 0);
34058 ssSetDWorkUsedAsDState(childS, 3, 1);
34059 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 474))[0]);
34060 }
34061
34062 (childS)->regDataType.arg1 = ((void *)(childS));
34063 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
34064 FcnSetErrorStatus);
34065 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
34066 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
34067 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
34068 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
34069
34070 /* registration */
34071#if defined(MATLAB_MEX_FILE)
34072
34073 {
34074 int_T i;
34075 mxArray *plhs[1];
34076 mxArray *prhs[4];
34077 double *pr;
34078 volatile int_T *intS = (int_T *)&childS;
34079 int_T addrlen = sizeof(SimStruct *);
34080 int_T m = addrlen/sizeof(int_T) + 1;
34081 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
34082 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
34083 pr = mxGetPr(prhs[1]);
34084 for (i = 0; i < m - 1; i++) {
34085 pr[i] = (double)intS[i];
34086 }
34087
34088 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
34089 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
34090 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
34091
34092 /* Reset port dimensions info functions because the S-function
34093 * and accelerator mex-files explicitly set their dimensions,
34094 * i.e., they are not dynamically sized. For this case, the
34095 * mex-file is responsible for the dimensions info memory
34096 * and Simulink should not free it. This is achieved by
34097 * setting the following two methods to NULL.
34098 */
34099 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
34100 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
34101
34102 /*
34103 * Setup function pointers and call mdlInitializeSizes via
34104 * simulink.c
34105 */
34106 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
34107 mxDestroyArray(plhs[0]);
34108 mxDestroyArray(prhs[0]);
34109 mxDestroyArray(prhs[1]);
34110 mxDestroyArray(prhs[2]);
34111 mxDestroyArray(prhs[3]);
34112 }
34113
34114#else
34115
34116 {
34117 LagFilter_sf(childS);
34118 sfcnInitializeSizes(childS);
34119 }
34120
34121#endif
34122
34123 sfcnInitializeSampleTimes(childS);
34124
34125 /* adjust sample time */
34126 ssSetSampleTime(childS, 0, 0.0);
34127 ssSetOffsetTime(childS, 0, 0.0);
34128 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
34129
34130 /* set compiled values of dynamic vector attributes */
34131 ssSetNumNonsampledZCs(childS, 0);
34132
34133 /* Update connectivity flags for each port */
34134 _ssSetInputPortConnected(childS, 0, 1);
34135 _ssSetInputPortConnected(childS, 1, 1);
34136 _ssSetInputPortConnected(childS, 2, 1);
34137 _ssSetInputPortConnected(childS, 3, 1);
34138 _ssSetInputPortConnected(childS, 4, 1);
34139 _ssSetInputPortConnected(childS, 5, 1);
34140 _ssSetOutputPortConnected(childS, 0, 1);
34141 _ssSetOutputPortBeingMerged(childS, 0, 0);
34142
34143 /* Update the BufferDstPort flags for each input port */
34144 _ssSetInputPortBufferDstPort(childS, 0, -1);
34145 _ssSetInputPortBufferDstPort(childS, 1, -1);
34146 _ssSetInputPortBufferDstPort(childS, 2, -1);
34147 _ssSetInputPortBufferDstPort(childS, 3, -1);
34148 _ssSetInputPortBufferDstPort(childS, 4, -1);
34149 _ssSetInputPortBufferDstPort(childS, 5, -1);
34150 }
34151
34152 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S238>/Generated S-Function8 (WashoutFilter_sf) */
34153 {
34154 SimStruct *childS = ssGetSFunction(rts, 129);
34155
34156 /* timing info */
34157 time_T *sfcnPeriod;
34158 time_T *sfcnOffset;
34159 int_T *sfcnTsMap;
34160 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
34161 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
34162 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
34163 ss_VALIDATE_MEMORY(rts,sfcnOffset);
34164 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
34165 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
34166 (void) memset((void*)sfcnPeriod, 0,
34167 sizeof(time_T)*1);
34168 (void) memset((void*)sfcnOffset, 0,
34169 sizeof(time_T)*1);
34170 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
34171 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
34172 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
34173
34174 /* Set up the mdlInfo pointer */
34175# ifdef USE_RTMODEL
34176
34177 {
34178 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
34179 struct _ssBlkInfo2));
34180 ss_VALIDATE_MEMORY(rts,blkInfo2);
34181 ssSetBlkInfo2Ptr(childS, blkInfo2);
34182 }
34183
34184 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
34185
34186# else
34187
34188 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
34189
34190# endif /* USE_RTMODEL */
34191
34192 /* Allocate memory of model methods 2 */
34193 {
34194 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
34195 malloc(sizeof(struct _ssSFcnModelMethods2));
34196 ss_VALIDATE_MEMORY(rts,methods2);
34197 ssSetModelMethods2(childS, methods2);
34198 }
34199
34200 /* Allocate memory of model methods 3 */
34201 {
34202 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
34203 malloc(sizeof(struct _ssSFcnModelMethods3));
34204 ss_VALIDATE_MEMORY(rts,methods3);
34205 ssSetModelMethods3(childS, methods3);
34206 }
34207
34208 /* Allocate memory for states auxilliary information */
34209 {
34210 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
34211 (sizeof(struct _ssStatesInfo2));
34212 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
34213 malloc(sizeof(ssPeriodicStatesInfo));
34214 ss_VALIDATE_MEMORY(rts,statesInfo2);
34215 ssSetStatesInfo2(childS, statesInfo2);
34216 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
34217 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
34218 }
34219
34220 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
34221 RegNumInputPorts);
34222 ssSetRegNumInputPortsFcnArg(childS,childS);
34223
34224 /* inputs */
34225 {
34226 struct _ssPortInputs *inputPortInfo =
34227 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
34228 ss_VALIDATE_MEMORY(rts,inputPortInfo);
34229 _ssSetNumInputPorts(childS, 6);
34230 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
34231
34232 /* port 0 */
34233 {
34234 real32_T const **sfcnUPtrs = (real32_T const **)
34235 malloc(1 * sizeof(real32_T *));
34236 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34237 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
34238 ssGetLocalBlockIO(rts))->dtCAS;
34239 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
34240 _ssSetInputPortNumDimensions(childS, 0, 1);
34241 ssSetInputPortWidth(childS, 0, 1);
34242 }
34243
34244 /* port 1 */
34245 {
34246 int8_T const **sfcnUPtrs = (int8_T const **)
34247 malloc(1 * sizeof(int8_T *));
34248 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34249 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
34250 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
34251 _ssSetInputPortNumDimensions(childS, 1, 1);
34252 ssSetInputPortWidth(childS, 1, 1);
34253 }
34254
34255 /* port 2 */
34256 {
34257 real32_T const **sfcnUPtrs = (real32_T const **)
34258 malloc(1 * sizeof(real32_T *));
34259 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34260 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
34261 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
34262 _ssSetInputPortNumDimensions(childS, 2, 1);
34263 ssSetInputPortWidth(childS, 2, 1);
34264 }
34265
34266 /* port 3 */
34267 {
34268 real32_T const **sfcnUPtrs = (real32_T const **)
34269 malloc(1 * sizeof(real32_T *));
34270 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34271 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
34272 ssGetLocalBlockIO(rts))->Saturation1_o;
34273 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
34274 _ssSetInputPortNumDimensions(childS, 3, 1);
34275 ssSetInputPortWidth(childS, 3, 1);
34276 }
34277
34278 /* port 4 */
34279 {
34280 real32_T const **sfcnUPtrs = (real32_T const **)
34281 malloc(1 * sizeof(real32_T *));
34282 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34283 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
34284 ssGetLocalBlockIO(rts))->Saturation1_o;
34285 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
34286 _ssSetInputPortNumDimensions(childS, 4, 1);
34287 ssSetInputPortWidth(childS, 4, 1);
34288 }
34289
34290 /* port 5 */
34291 {
34292 real32_T const **sfcnUPtrs = (real32_T const **)
34293 malloc(1 * sizeof(real32_T *));
34294 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34295 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
34296 ssGetLocalBlockIO(rts))->GeneratedSFunction4_ab;
34297 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
34298 _ssSetInputPortNumDimensions(childS, 5, 1);
34299 ssSetInputPortWidth(childS, 5, 1);
34300 }
34301 }
34302
34303 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
34304 RegNumOutputPorts);
34305 ssSetRegNumOutputPortsFcnArg(childS,childS);
34306
34307 /* outputs */
34308 {
34309 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
34310 calloc(1, sizeof(struct _ssPortOutputs));
34311 ss_VALIDATE_MEMORY(rts,outputPortInfo);
34312 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
34313 _ssSetNumOutputPorts(childS, 1);
34314
34315 /* port 0 */
34316 {
34317 _ssSetOutputPortNumDimensions(childS, 0, 1);
34318 ssSetOutputPortWidth(childS, 0, 1);
34319 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
34320 ssGetLocalBlockIO(rts))->GeneratedSFunction8));
34321 }
34322 }
34323
34324 /* path info */
34325 _ssSetModelName(childS, "WashoutFilter_sf");
34326 _ssSetPath(childS,
34327 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/ high pass filter/Generated S-Function8");
34328 if (ssGetRTModel(rts) == (NULL)) {
34329 _ssSetParentSS(childS, rts);
34330 _ssSetRootSS(childS, ssGetRootSS(rts));
34331 } else {
34332 ssSetRTModel(childS,ssGetRTModel(rts));
34333 _ssSetParentSS(childS, (NULL));
34334 _ssSetRootSS(childS, childS);
34335 }
34336
34337 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
34338
34339 /* work vectors */
34340 {
34341 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
34342 (4 * sizeof(struct _ssDWorkRecord));
34343 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
34344 calloc(4, sizeof(struct _ssDWorkAuxRecord));
34345 ss_VALIDATE_MEMORY(rts,dWorkRecord);
34346 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
34347 ssSetSFcnDWork(childS, dWorkRecord);
34348 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
34349 _ssSetNumDWork(childS, 4);
34350
34351 /* DWORK0 */
34352 ssSetDWorkWidth(childS, 0, 1);
34353 ssSetDWorkDataType(childS, 0,SS_SINGLE);
34354 ssSetDWorkComplexSignal(childS, 0, 0);
34355 ssSetDWorkUsedAsDState(childS, 0, 1);
34356 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 247))[0]);
34357
34358 /* DWORK1 */
34359 ssSetDWorkWidth(childS, 1, 1);
34360 ssSetDWorkDataType(childS, 1,SS_SINGLE);
34361 ssSetDWorkComplexSignal(childS, 1, 0);
34362 ssSetDWorkUsedAsDState(childS, 1, 1);
34363 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 248))[0]);
34364
34365 /* DWORK2 */
34366 ssSetDWorkWidth(childS, 2, 1);
34367 ssSetDWorkDataType(childS, 2,SS_INT8);
34368 ssSetDWorkComplexSignal(childS, 2, 0);
34369 ssSetDWorkUsedAsDState(childS, 2, 1);
34370 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 475))[0]);
34371
34372 /* DWORK3 */
34373 ssSetDWorkWidth(childS, 3, 1);
34374 ssSetDWorkDataType(childS, 3,SS_INT8);
34375 ssSetDWorkComplexSignal(childS, 3, 0);
34376 ssSetDWorkUsedAsDState(childS, 3, 1);
34377 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 476))[0]);
34378 }
34379
34380 (childS)->regDataType.arg1 = ((void *)(childS));
34381 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
34382 FcnSetErrorStatus);
34383 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
34384 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
34385 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
34386 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
34387
34388 /* registration */
34389#if defined(MATLAB_MEX_FILE)
34390
34391 {
34392 int_T i;
34393 mxArray *plhs[1];
34394 mxArray *prhs[4];
34395 double *pr;
34396 volatile int_T *intS = (int_T *)&childS;
34397 int_T addrlen = sizeof(SimStruct *);
34398 int_T m = addrlen/sizeof(int_T) + 1;
34399 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
34400 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
34401 pr = mxGetPr(prhs[1]);
34402 for (i = 0; i < m - 1; i++) {
34403 pr[i] = (double)intS[i];
34404 }
34405
34406 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
34407 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
34408 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
34409
34410 /* Reset port dimensions info functions because the S-function
34411 * and accelerator mex-files explicitly set their dimensions,
34412 * i.e., they are not dynamically sized. For this case, the
34413 * mex-file is responsible for the dimensions info memory
34414 * and Simulink should not free it. This is achieved by
34415 * setting the following two methods to NULL.
34416 */
34417 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
34418 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
34419
34420 /*
34421 * Setup function pointers and call mdlInitializeSizes via
34422 * simulink.c
34423 */
34424 mexCallMATLAB(1, plhs, 4, prhs, "WashoutFilter_sf");
34425 mxDestroyArray(plhs[0]);
34426 mxDestroyArray(prhs[0]);
34427 mxDestroyArray(prhs[1]);
34428 mxDestroyArray(prhs[2]);
34429 mxDestroyArray(prhs[3]);
34430 }
34431
34432#else
34433
34434 {
34435 WashoutFilter_sf(childS);
34436 sfcnInitializeSizes(childS);
34437 }
34438
34439#endif
34440
34441 sfcnInitializeSampleTimes(childS);
34442
34443 /* adjust sample time */
34444 ssSetSampleTime(childS, 0, 0.0);
34445 ssSetOffsetTime(childS, 0, 0.0);
34446 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
34447
34448 /* set compiled values of dynamic vector attributes */
34449 ssSetNumNonsampledZCs(childS, 0);
34450
34451 /* Update connectivity flags for each port */
34452 _ssSetInputPortConnected(childS, 0, 1);
34453 _ssSetInputPortConnected(childS, 1, 1);
34454 _ssSetInputPortConnected(childS, 2, 1);
34455 _ssSetInputPortConnected(childS, 3, 1);
34456 _ssSetInputPortConnected(childS, 4, 1);
34457 _ssSetInputPortConnected(childS, 5, 1);
34458 _ssSetOutputPortConnected(childS, 0, 1);
34459 _ssSetOutputPortBeingMerged(childS, 0, 0);
34460
34461 /* Update the BufferDstPort flags for each input port */
34462 _ssSetInputPortBufferDstPort(childS, 0, -1);
34463 _ssSetInputPortBufferDstPort(childS, 1, -1);
34464 _ssSetInputPortBufferDstPort(childS, 2, -1);
34465 _ssSetInputPortBufferDstPort(childS, 3, -1);
34466 _ssSetInputPortBufferDstPort(childS, 4, -1);
34467 _ssSetInputPortBufferDstPort(childS, 5, -1);
34468 }
34469
34470 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S244>/Generated S-Function (Gain_sf) */
34471 {
34472 SimStruct *childS = ssGetSFunction(rts, 130);
34473
34474 /* timing info */
34475 time_T *sfcnPeriod;
34476 time_T *sfcnOffset;
34477 int_T *sfcnTsMap;
34478 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
34479 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
34480 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
34481 ss_VALIDATE_MEMORY(rts,sfcnOffset);
34482 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
34483 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
34484 (void) memset((void*)sfcnPeriod, 0,
34485 sizeof(time_T)*1);
34486 (void) memset((void*)sfcnOffset, 0,
34487 sizeof(time_T)*1);
34488 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
34489 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
34490 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
34491
34492 /* Set up the mdlInfo pointer */
34493# ifdef USE_RTMODEL
34494
34495 {
34496 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
34497 struct _ssBlkInfo2));
34498 ss_VALIDATE_MEMORY(rts,blkInfo2);
34499 ssSetBlkInfo2Ptr(childS, blkInfo2);
34500 }
34501
34502 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
34503
34504# else
34505
34506 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
34507
34508# endif /* USE_RTMODEL */
34509
34510 /* Allocate memory of model methods 2 */
34511 {
34512 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
34513 malloc(sizeof(struct _ssSFcnModelMethods2));
34514 ss_VALIDATE_MEMORY(rts,methods2);
34515 ssSetModelMethods2(childS, methods2);
34516 }
34517
34518 /* Allocate memory of model methods 3 */
34519 {
34520 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
34521 malloc(sizeof(struct _ssSFcnModelMethods3));
34522 ss_VALIDATE_MEMORY(rts,methods3);
34523 ssSetModelMethods3(childS, methods3);
34524 }
34525
34526 /* Allocate memory for states auxilliary information */
34527 {
34528 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
34529 (sizeof(struct _ssStatesInfo2));
34530 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
34531 malloc(sizeof(ssPeriodicStatesInfo));
34532 ss_VALIDATE_MEMORY(rts,statesInfo2);
34533 ssSetStatesInfo2(childS, statesInfo2);
34534 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
34535 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
34536 }
34537
34538 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
34539 RegNumInputPorts);
34540 ssSetRegNumInputPortsFcnArg(childS,childS);
34541
34542 /* inputs */
34543 {
34544 struct _ssPortInputs *inputPortInfo =
34545 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
34546 ss_VALIDATE_MEMORY(rts,inputPortInfo);
34547 _ssSetNumInputPorts(childS, 2);
34548 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
34549
34550 /* port 0 */
34551 {
34552 real32_T const **sfcnUPtrs = (real32_T const **)
34553 malloc(1 * sizeof(real32_T *));
34554 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34555 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
34556 ssGetLocalBlockIO(rts))->GeneratedSFunction8;
34557 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
34558 _ssSetInputPortNumDimensions(childS, 0, 1);
34559 ssSetInputPortWidth(childS, 0, 1);
34560 }
34561
34562 /* port 1 */
34563 {
34564 real32_T const **sfcnUPtrs = (real32_T const **)
34565 malloc(1 * sizeof(real32_T *));
34566 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34567 sfcnUPtrs[0] = (real32_T const *)
34568 &AFCS_MODEL1_ConstP.Constant23_Value;
34569 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
34570 _ssSetInputPortNumDimensions(childS, 1, 1);
34571 ssSetInputPortWidth(childS, 1, 1);
34572 }
34573 }
34574
34575 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
34576 RegNumOutputPorts);
34577 ssSetRegNumOutputPortsFcnArg(childS,childS);
34578
34579 /* outputs */
34580 {
34581 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
34582 calloc(1, sizeof(struct _ssPortOutputs));
34583 ss_VALIDATE_MEMORY(rts,outputPortInfo);
34584 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
34585 _ssSetNumOutputPorts(childS, 1);
34586
34587 /* port 0 */
34588 {
34589 _ssSetOutputPortNumDimensions(childS, 0, 1);
34590 ssSetOutputPortWidth(childS, 0, 1);
34591 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
34592 ssGetLocalBlockIO(rts))->MinMax));
34593 }
34594 }
34595
34596 /* path info */
34597 _ssSetModelName(childS, "Gain_sf");
34598 _ssSetPath(childS,
34599 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain2/Generated S-Function");
34600 if (ssGetRTModel(rts) == (NULL)) {
34601 _ssSetParentSS(childS, rts);
34602 _ssSetRootSS(childS, ssGetRootSS(rts));
34603 } else {
34604 ssSetRTModel(childS,ssGetRTModel(rts));
34605 _ssSetParentSS(childS, (NULL));
34606 _ssSetRootSS(childS, childS);
34607 }
34608
34609 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
34610 (childS)->regDataType.arg1 = ((void *)(childS));
34611 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
34612 FcnSetErrorStatus);
34613 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
34614 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
34615 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
34616 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
34617
34618 /* registration */
34619#if defined(MATLAB_MEX_FILE)
34620
34621 {
34622 int_T i;
34623 mxArray *plhs[1];
34624 mxArray *prhs[4];
34625 double *pr;
34626 volatile int_T *intS = (int_T *)&childS;
34627 int_T addrlen = sizeof(SimStruct *);
34628 int_T m = addrlen/sizeof(int_T) + 1;
34629 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
34630 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
34631 pr = mxGetPr(prhs[1]);
34632 for (i = 0; i < m - 1; i++) {
34633 pr[i] = (double)intS[i];
34634 }
34635
34636 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
34637 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
34638 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
34639
34640 /* Reset port dimensions info functions because the S-function
34641 * and accelerator mex-files explicitly set their dimensions,
34642 * i.e., they are not dynamically sized. For this case, the
34643 * mex-file is responsible for the dimensions info memory
34644 * and Simulink should not free it. This is achieved by
34645 * setting the following two methods to NULL.
34646 */
34647 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
34648 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
34649
34650 /*
34651 * Setup function pointers and call mdlInitializeSizes via
34652 * simulink.c
34653 */
34654 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
34655 mxDestroyArray(plhs[0]);
34656 mxDestroyArray(prhs[0]);
34657 mxDestroyArray(prhs[1]);
34658 mxDestroyArray(prhs[2]);
34659 mxDestroyArray(prhs[3]);
34660 }
34661
34662#else
34663
34664 {
34665 Gain_sf(childS);
34666 sfcnInitializeSizes(childS);
34667 }
34668
34669#endif
34670
34671 sfcnInitializeSampleTimes(childS);
34672
34673 /* adjust sample time */
34674 ssSetSampleTime(childS, 0, 0.0);
34675 ssSetOffsetTime(childS, 0, 0.0);
34676 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
34677
34678 /* set compiled values of dynamic vector attributes */
34679 ssSetNumNonsampledZCs(childS, 0);
34680
34681 /* Update connectivity flags for each port */
34682 _ssSetInputPortConnected(childS, 0, 1);
34683 _ssSetInputPortConnected(childS, 1, 1);
34684 _ssSetOutputPortConnected(childS, 0, 1);
34685 _ssSetOutputPortBeingMerged(childS, 0, 0);
34686
34687 /* Update the BufferDstPort flags for each input port */
34688 _ssSetInputPortBufferDstPort(childS, 0, -1);
34689 _ssSetInputPortBufferDstPort(childS, 1, -1);
34690 }
34691
34692 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S243>/Generated S-Function (Gain_sf) */
34693 {
34694 SimStruct *childS = ssGetSFunction(rts, 131);
34695
34696 /* timing info */
34697 time_T *sfcnPeriod;
34698 time_T *sfcnOffset;
34699 int_T *sfcnTsMap;
34700 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
34701 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
34702 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
34703 ss_VALIDATE_MEMORY(rts,sfcnOffset);
34704 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
34705 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
34706 (void) memset((void*)sfcnPeriod, 0,
34707 sizeof(time_T)*1);
34708 (void) memset((void*)sfcnOffset, 0,
34709 sizeof(time_T)*1);
34710 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
34711 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
34712 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
34713
34714 /* Set up the mdlInfo pointer */
34715# ifdef USE_RTMODEL
34716
34717 {
34718 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
34719 struct _ssBlkInfo2));
34720 ss_VALIDATE_MEMORY(rts,blkInfo2);
34721 ssSetBlkInfo2Ptr(childS, blkInfo2);
34722 }
34723
34724 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
34725
34726# else
34727
34728 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
34729
34730# endif /* USE_RTMODEL */
34731
34732 /* Allocate memory of model methods 2 */
34733 {
34734 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
34735 malloc(sizeof(struct _ssSFcnModelMethods2));
34736 ss_VALIDATE_MEMORY(rts,methods2);
34737 ssSetModelMethods2(childS, methods2);
34738 }
34739
34740 /* Allocate memory of model methods 3 */
34741 {
34742 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
34743 malloc(sizeof(struct _ssSFcnModelMethods3));
34744 ss_VALIDATE_MEMORY(rts,methods3);
34745 ssSetModelMethods3(childS, methods3);
34746 }
34747
34748 /* Allocate memory for states auxilliary information */
34749 {
34750 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
34751 (sizeof(struct _ssStatesInfo2));
34752 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
34753 malloc(sizeof(ssPeriodicStatesInfo));
34754 ss_VALIDATE_MEMORY(rts,statesInfo2);
34755 ssSetStatesInfo2(childS, statesInfo2);
34756 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
34757 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
34758 }
34759
34760 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
34761 RegNumInputPorts);
34762 ssSetRegNumInputPortsFcnArg(childS,childS);
34763
34764 /* inputs */
34765 {
34766 struct _ssPortInputs *inputPortInfo =
34767 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
34768 ss_VALIDATE_MEMORY(rts,inputPortInfo);
34769 _ssSetNumInputPorts(childS, 2);
34770 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
34771
34772 /* port 0 */
34773 {
34774 real32_T const **sfcnUPtrs = (real32_T const **)
34775 malloc(1 * sizeof(real32_T *));
34776 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34777 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
34778 ssGetLocalBlockIO(rts))->Sum5;
34779 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
34780 _ssSetInputPortNumDimensions(childS, 0, 1);
34781 ssSetInputPortWidth(childS, 0, 1);
34782 }
34783
34784 /* port 1 */
34785 {
34786 real32_T const **sfcnUPtrs = (real32_T const **)
34787 malloc(1 * sizeof(real32_T *));
34788 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34789 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
34790 ssGetLocalBlockIO(rts))->Product2_d;
34791 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
34792 _ssSetInputPortNumDimensions(childS, 1, 1);
34793 ssSetInputPortWidth(childS, 1, 1);
34794 }
34795 }
34796
34797 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
34798 RegNumOutputPorts);
34799 ssSetRegNumOutputPortsFcnArg(childS,childS);
34800
34801 /* outputs */
34802 {
34803 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
34804 calloc(1, sizeof(struct _ssPortOutputs));
34805 ss_VALIDATE_MEMORY(rts,outputPortInfo);
34806 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
34807 _ssSetNumOutputPorts(childS, 1);
34808
34809 /* port 0 */
34810 {
34811 _ssSetOutputPortNumDimensions(childS, 0, 1);
34812 ssSetOutputPortWidth(childS, 0, 1);
34813 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
34814 ssGetLocalBlockIO(rts))->GeneratedSFunction_dc));
34815 }
34816 }
34817
34818 /* path info */
34819 _ssSetModelName(childS, "Gain_sf");
34820 _ssSetPath(childS,
34821 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/lat/gain1/Generated S-Function");
34822 if (ssGetRTModel(rts) == (NULL)) {
34823 _ssSetParentSS(childS, rts);
34824 _ssSetRootSS(childS, ssGetRootSS(rts));
34825 } else {
34826 ssSetRTModel(childS,ssGetRTModel(rts));
34827 _ssSetParentSS(childS, (NULL));
34828 _ssSetRootSS(childS, childS);
34829 }
34830
34831 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
34832 (childS)->regDataType.arg1 = ((void *)(childS));
34833 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
34834 FcnSetErrorStatus);
34835 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
34836 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
34837 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
34838 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
34839
34840 /* registration */
34841#if defined(MATLAB_MEX_FILE)
34842
34843 {
34844 int_T i;
34845 mxArray *plhs[1];
34846 mxArray *prhs[4];
34847 double *pr;
34848 volatile int_T *intS = (int_T *)&childS;
34849 int_T addrlen = sizeof(SimStruct *);
34850 int_T m = addrlen/sizeof(int_T) + 1;
34851 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
34852 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
34853 pr = mxGetPr(prhs[1]);
34854 for (i = 0; i < m - 1; i++) {
34855 pr[i] = (double)intS[i];
34856 }
34857
34858 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
34859 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
34860 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
34861
34862 /* Reset port dimensions info functions because the S-function
34863 * and accelerator mex-files explicitly set their dimensions,
34864 * i.e., they are not dynamically sized. For this case, the
34865 * mex-file is responsible for the dimensions info memory
34866 * and Simulink should not free it. This is achieved by
34867 * setting the following two methods to NULL.
34868 */
34869 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
34870 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
34871
34872 /*
34873 * Setup function pointers and call mdlInitializeSizes via
34874 * simulink.c
34875 */
34876 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
34877 mxDestroyArray(plhs[0]);
34878 mxDestroyArray(prhs[0]);
34879 mxDestroyArray(prhs[1]);
34880 mxDestroyArray(prhs[2]);
34881 mxDestroyArray(prhs[3]);
34882 }
34883
34884#else
34885
34886 {
34887 Gain_sf(childS);
34888 sfcnInitializeSizes(childS);
34889 }
34890
34891#endif
34892
34893 sfcnInitializeSampleTimes(childS);
34894
34895 /* adjust sample time */
34896 ssSetSampleTime(childS, 0, 0.0);
34897 ssSetOffsetTime(childS, 0, 0.0);
34898 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
34899
34900 /* set compiled values of dynamic vector attributes */
34901 ssSetNumNonsampledZCs(childS, 0);
34902
34903 /* Update connectivity flags for each port */
34904 _ssSetInputPortConnected(childS, 0, 1);
34905 _ssSetInputPortConnected(childS, 1, 1);
34906 _ssSetOutputPortConnected(childS, 0, 1);
34907 _ssSetOutputPortBeingMerged(childS, 0, 0);
34908
34909 /* Update the BufferDstPort flags for each input port */
34910 _ssSetInputPortBufferDstPort(childS, 0, -1);
34911 _ssSetInputPortBufferDstPort(childS, 1, -1);
34912 }
34913
34914 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S225>/Generated S-Function1 (SaturationLimiter_sf) */
34915 {
34916 SimStruct *childS = ssGetSFunction(rts, 132);
34917
34918 /* timing info */
34919 time_T *sfcnPeriod;
34920 time_T *sfcnOffset;
34921 int_T *sfcnTsMap;
34922 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
34923 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
34924 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
34925 ss_VALIDATE_MEMORY(rts,sfcnOffset);
34926 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
34927 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
34928 (void) memset((void*)sfcnPeriod, 0,
34929 sizeof(time_T)*1);
34930 (void) memset((void*)sfcnOffset, 0,
34931 sizeof(time_T)*1);
34932 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
34933 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
34934 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
34935
34936 /* Set up the mdlInfo pointer */
34937# ifdef USE_RTMODEL
34938
34939 {
34940 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
34941 struct _ssBlkInfo2));
34942 ss_VALIDATE_MEMORY(rts,blkInfo2);
34943 ssSetBlkInfo2Ptr(childS, blkInfo2);
34944 }
34945
34946 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
34947
34948# else
34949
34950 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
34951
34952# endif /* USE_RTMODEL */
34953
34954 /* Allocate memory of model methods 2 */
34955 {
34956 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
34957 malloc(sizeof(struct _ssSFcnModelMethods2));
34958 ss_VALIDATE_MEMORY(rts,methods2);
34959 ssSetModelMethods2(childS, methods2);
34960 }
34961
34962 /* Allocate memory of model methods 3 */
34963 {
34964 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
34965 malloc(sizeof(struct _ssSFcnModelMethods3));
34966 ss_VALIDATE_MEMORY(rts,methods3);
34967 ssSetModelMethods3(childS, methods3);
34968 }
34969
34970 /* Allocate memory for states auxilliary information */
34971 {
34972 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
34973 (sizeof(struct _ssStatesInfo2));
34974 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
34975 malloc(sizeof(ssPeriodicStatesInfo));
34976 ss_VALIDATE_MEMORY(rts,statesInfo2);
34977 ssSetStatesInfo2(childS, statesInfo2);
34978 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
34979 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
34980 }
34981
34982 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
34983 RegNumInputPorts);
34984 ssSetRegNumInputPortsFcnArg(childS,childS);
34985
34986 /* inputs */
34987 {
34988 struct _ssPortInputs *inputPortInfo =
34989 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
34990 ss_VALIDATE_MEMORY(rts,inputPortInfo);
34991 _ssSetNumInputPorts(childS, 3);
34992 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
34993
34994 /* port 0 */
34995 {
34996 real32_T const **sfcnUPtrs = (real32_T const **)
34997 malloc(1 * sizeof(real32_T *));
34998 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
34999 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
35000 ssGetLocalBlockIO(rts))->Switch_dd;
35001 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
35002 _ssSetInputPortNumDimensions(childS, 0, 1);
35003 ssSetInputPortWidth(childS, 0, 1);
35004 }
35005
35006 /* port 1 */
35007 {
35008 real32_T const **sfcnUPtrs = (real32_T const **)
35009 malloc(1 * sizeof(real32_T *));
35010 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35011 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled130;
35012 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
35013 _ssSetInputPortNumDimensions(childS, 1, 1);
35014 ssSetInputPortWidth(childS, 1, 1);
35015 }
35016
35017 /* port 2 */
35018 {
35019 real32_T const **sfcnUPtrs = (real32_T const **)
35020 malloc(1 * sizeof(real32_T *));
35021 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35022 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled131;
35023 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
35024 _ssSetInputPortNumDimensions(childS, 2, 1);
35025 ssSetInputPortWidth(childS, 2, 1);
35026 }
35027 }
35028
35029 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
35030 RegNumOutputPorts);
35031 ssSetRegNumOutputPortsFcnArg(childS,childS);
35032
35033 /* outputs */
35034 {
35035 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
35036 calloc(1, sizeof(struct _ssPortOutputs));
35037 ss_VALIDATE_MEMORY(rts,outputPortInfo);
35038 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
35039 _ssSetNumOutputPorts(childS, 1);
35040
35041 /* port 0 */
35042 {
35043 _ssSetOutputPortNumDimensions(childS, 0, 1);
35044 ssSetOutputPortWidth(childS, 0, 1);
35045 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
35046 ssGetLocalBlockIO(rts))->GeneratedSFunction1_en));
35047 }
35048 }
35049
35050 /* path info */
35051 _ssSetModelName(childS, "SaturationLimiter_sf");
35052 _ssSetPath(childS,
35053 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/Saturation Limiter1/Generated S-Function1");
35054 if (ssGetRTModel(rts) == (NULL)) {
35055 _ssSetParentSS(childS, rts);
35056 _ssSetRootSS(childS, ssGetRootSS(rts));
35057 } else {
35058 ssSetRTModel(childS,ssGetRTModel(rts));
35059 _ssSetParentSS(childS, (NULL));
35060 _ssSetRootSS(childS, childS);
35061 }
35062
35063 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
35064 (childS)->regDataType.arg1 = ((void *)(childS));
35065 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
35066 FcnSetErrorStatus);
35067 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
35068 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
35069 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
35070 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
35071
35072 /* registration */
35073#if defined(MATLAB_MEX_FILE)
35074
35075 {
35076 int_T i;
35077 mxArray *plhs[1];
35078 mxArray *prhs[4];
35079 double *pr;
35080 volatile int_T *intS = (int_T *)&childS;
35081 int_T addrlen = sizeof(SimStruct *);
35082 int_T m = addrlen/sizeof(int_T) + 1;
35083 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
35084 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
35085 pr = mxGetPr(prhs[1]);
35086 for (i = 0; i < m - 1; i++) {
35087 pr[i] = (double)intS[i];
35088 }
35089
35090 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
35091 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
35092 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
35093
35094 /* Reset port dimensions info functions because the S-function
35095 * and accelerator mex-files explicitly set their dimensions,
35096 * i.e., they are not dynamically sized. For this case, the
35097 * mex-file is responsible for the dimensions info memory
35098 * and Simulink should not free it. This is achieved by
35099 * setting the following two methods to NULL.
35100 */
35101 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
35102 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
35103
35104 /*
35105 * Setup function pointers and call mdlInitializeSizes via
35106 * simulink.c
35107 */
35108 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
35109 mxDestroyArray(plhs[0]);
35110 mxDestroyArray(prhs[0]);
35111 mxDestroyArray(prhs[1]);
35112 mxDestroyArray(prhs[2]);
35113 mxDestroyArray(prhs[3]);
35114 }
35115
35116#else
35117
35118 {
35119 SaturationLimiter_sf(childS);
35120 sfcnInitializeSizes(childS);
35121 }
35122
35123#endif
35124
35125 sfcnInitializeSampleTimes(childS);
35126
35127 /* adjust sample time */
35128 ssSetSampleTime(childS, 0, 0.0);
35129 ssSetOffsetTime(childS, 0, 0.0);
35130 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
35131
35132 /* set compiled values of dynamic vector attributes */
35133 ssSetNumNonsampledZCs(childS, 0);
35134
35135 /* Update connectivity flags for each port */
35136 _ssSetInputPortConnected(childS, 0, 1);
35137 _ssSetInputPortConnected(childS, 1, 1);
35138 _ssSetInputPortConnected(childS, 2, 1);
35139 _ssSetOutputPortConnected(childS, 0, 1);
35140 _ssSetOutputPortBeingMerged(childS, 0, 0);
35141
35142 /* Update the BufferDstPort flags for each input port */
35143 _ssSetInputPortBufferDstPort(childS, 0, -1);
35144 _ssSetInputPortBufferDstPort(childS, 1, -1);
35145 _ssSetInputPortBufferDstPort(childS, 2, -1);
35146 }
35147
35148 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S223>/Generated S-Function7 (RateLimiter_sf) */
35149 {
35150 SimStruct *childS = ssGetSFunction(rts, 133);
35151
35152 /* timing info */
35153 time_T *sfcnPeriod;
35154 time_T *sfcnOffset;
35155 int_T *sfcnTsMap;
35156 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
35157 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
35158 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
35159 ss_VALIDATE_MEMORY(rts,sfcnOffset);
35160 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
35161 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
35162 (void) memset((void*)sfcnPeriod, 0,
35163 sizeof(time_T)*1);
35164 (void) memset((void*)sfcnOffset, 0,
35165 sizeof(time_T)*1);
35166 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
35167 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
35168 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
35169
35170 /* Set up the mdlInfo pointer */
35171# ifdef USE_RTMODEL
35172
35173 {
35174 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
35175 struct _ssBlkInfo2));
35176 ss_VALIDATE_MEMORY(rts,blkInfo2);
35177 ssSetBlkInfo2Ptr(childS, blkInfo2);
35178 }
35179
35180 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
35181
35182# else
35183
35184 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
35185
35186# endif /* USE_RTMODEL */
35187
35188 /* Allocate memory of model methods 2 */
35189 {
35190 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
35191 malloc(sizeof(struct _ssSFcnModelMethods2));
35192 ss_VALIDATE_MEMORY(rts,methods2);
35193 ssSetModelMethods2(childS, methods2);
35194 }
35195
35196 /* Allocate memory of model methods 3 */
35197 {
35198 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
35199 malloc(sizeof(struct _ssSFcnModelMethods3));
35200 ss_VALIDATE_MEMORY(rts,methods3);
35201 ssSetModelMethods3(childS, methods3);
35202 }
35203
35204 /* Allocate memory for states auxilliary information */
35205 {
35206 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
35207 (sizeof(struct _ssStatesInfo2));
35208 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
35209 malloc(sizeof(ssPeriodicStatesInfo));
35210 ss_VALIDATE_MEMORY(rts,statesInfo2);
35211 ssSetStatesInfo2(childS, statesInfo2);
35212 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
35213 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
35214 }
35215
35216 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
35217 RegNumInputPorts);
35218 ssSetRegNumInputPortsFcnArg(childS,childS);
35219
35220 /* inputs */
35221 {
35222 struct _ssPortInputs *inputPortInfo =
35223 (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));
35224 ss_VALIDATE_MEMORY(rts,inputPortInfo);
35225 _ssSetNumInputPorts(childS, 5);
35226 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
35227
35228 /* port 0 */
35229 {
35230 int8_T const **sfcnUPtrs = (int8_T const **)
35231 malloc(1 * sizeof(int8_T *));
35232 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35233 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
35234 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
35235 _ssSetInputPortNumDimensions(childS, 0, 1);
35236 ssSetInputPortWidth(childS, 0, 1);
35237 }
35238
35239 /* port 1 */
35240 {
35241 real32_T const **sfcnUPtrs = (real32_T const **)
35242 malloc(1 * sizeof(real32_T *));
35243 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35244 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
35245 ssGetLocalBlockIO(rts))->TmpSignalConversionAtCodeReus_b[4];
35246 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
35247 _ssSetInputPortNumDimensions(childS, 1, 1);
35248 ssSetInputPortWidth(childS, 1, 1);
35249 }
35250
35251 /* port 2 */
35252 {
35253 real32_T const **sfcnUPtrs = (real32_T const **)
35254 malloc(1 * sizeof(real32_T *));
35255 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35256 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled125;
35257 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
35258 _ssSetInputPortNumDimensions(childS, 2, 1);
35259 ssSetInputPortWidth(childS, 2, 1);
35260 }
35261
35262 /* port 3 */
35263 {
35264 real32_T const **sfcnUPtrs = (real32_T const **)
35265 malloc(1 * sizeof(real32_T *));
35266 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35267 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
35268 ssGetLocalBlockIO(rts))->dtCAS;
35269 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
35270 _ssSetInputPortNumDimensions(childS, 3, 1);
35271 ssSetInputPortWidth(childS, 3, 1);
35272 }
35273
35274 /* port 4 */
35275 {
35276 real32_T const **sfcnUPtrs = (real32_T const **)
35277 malloc(1 * sizeof(real32_T *));
35278 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35279 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
35280 ssGetLocalBlockIO(rts))->GeneratedSFunction1_en;
35281 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
35282 _ssSetInputPortNumDimensions(childS, 4, 1);
35283 ssSetInputPortWidth(childS, 4, 1);
35284 }
35285 }
35286
35287 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
35288 RegNumOutputPorts);
35289 ssSetRegNumOutputPortsFcnArg(childS,childS);
35290
35291 /* outputs */
35292 {
35293 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
35294 calloc(2, sizeof(struct _ssPortOutputs));
35295 ss_VALIDATE_MEMORY(rts,outputPortInfo);
35296 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
35297 _ssSetNumOutputPorts(childS, 2);
35298
35299 /* port 0 */
35300 {
35301 _ssSetOutputPortNumDimensions(childS, 0, 1);
35302 ssSetOutputPortWidth(childS, 0, 1);
35303 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
35304 ssGetLocalBlockIO(rts))->Saturation8));
35305 }
35306
35307 /* port 1 */
35308 {
35309 _ssSetOutputPortNumDimensions(childS, 1, 1);
35310 ssSetOutputPortWidth(childS, 1, 1);
35311 _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)
35312 ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2));
35313 }
35314 }
35315
35316 /* path info */
35317 _ssSetModelName(childS, "RateLimiter_sf");
35318 _ssSetPath(childS,
35319 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/Rate Limiter1/Generated S-Function7");
35320 if (ssGetRTModel(rts) == (NULL)) {
35321 _ssSetParentSS(childS, rts);
35322 _ssSetRootSS(childS, ssGetRootSS(rts));
35323 } else {
35324 ssSetRTModel(childS,ssGetRTModel(rts));
35325 _ssSetParentSS(childS, (NULL));
35326 _ssSetRootSS(childS, childS);
35327 }
35328
35329 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
35330
35331 /* work vectors */
35332 {
35333 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
35334 (3 * sizeof(struct _ssDWorkRecord));
35335 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
35336 calloc(3, sizeof(struct _ssDWorkAuxRecord));
35337 ss_VALIDATE_MEMORY(rts,dWorkRecord);
35338 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
35339 ssSetSFcnDWork(childS, dWorkRecord);
35340 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
35341 _ssSetNumDWork(childS, 3);
35342
35343 /* DWORK0 */
35344 ssSetDWorkWidth(childS, 0, 1);
35345 ssSetDWorkDataType(childS, 0,SS_SINGLE);
35346 ssSetDWorkComplexSignal(childS, 0, 0);
35347 ssSetDWorkUsedAsDState(childS, 0, 1);
35348 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 249))[0]);
35349
35350 /* DWORK1 */
35351 ssSetDWorkWidth(childS, 1, 1);
35352 ssSetDWorkDataType(childS, 1,SS_INT8);
35353 ssSetDWorkComplexSignal(childS, 1, 0);
35354 ssSetDWorkUsedAsDState(childS, 1, 1);
35355 _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 477))[0]);
35356
35357 /* DWORK2 */
35358 ssSetDWorkWidth(childS, 2, 1);
35359 ssSetDWorkDataType(childS, 2,SS_INT8);
35360 ssSetDWorkComplexSignal(childS, 2, 0);
35361 ssSetDWorkUsedAsDState(childS, 2, 1);
35362 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 478))[0]);
35363 }
35364
35365 (childS)->regDataType.arg1 = ((void *)(childS));
35366 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
35367 FcnSetErrorStatus);
35368 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
35369 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
35370 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
35371 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
35372
35373 /* registration */
35374#if defined(MATLAB_MEX_FILE)
35375
35376 {
35377 int_T i;
35378 mxArray *plhs[1];
35379 mxArray *prhs[4];
35380 double *pr;
35381 volatile int_T *intS = (int_T *)&childS;
35382 int_T addrlen = sizeof(SimStruct *);
35383 int_T m = addrlen/sizeof(int_T) + 1;
35384 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
35385 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
35386 pr = mxGetPr(prhs[1]);
35387 for (i = 0; i < m - 1; i++) {
35388 pr[i] = (double)intS[i];
35389 }
35390
35391 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
35392 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
35393 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
35394
35395 /* Reset port dimensions info functions because the S-function
35396 * and accelerator mex-files explicitly set their dimensions,
35397 * i.e., they are not dynamically sized. For this case, the
35398 * mex-file is responsible for the dimensions info memory
35399 * and Simulink should not free it. This is achieved by
35400 * setting the following two methods to NULL.
35401 */
35402 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
35403 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
35404
35405 /*
35406 * Setup function pointers and call mdlInitializeSizes via
35407 * simulink.c
35408 */
35409 mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");
35410 mxDestroyArray(plhs[0]);
35411 mxDestroyArray(prhs[0]);
35412 mxDestroyArray(prhs[1]);
35413 mxDestroyArray(prhs[2]);
35414 mxDestroyArray(prhs[3]);
35415 }
35416
35417#else
35418
35419 {
35420 RateLimiter_sf(childS);
35421 sfcnInitializeSizes(childS);
35422 }
35423
35424#endif
35425
35426 sfcnInitializeSampleTimes(childS);
35427
35428 /* adjust sample time */
35429 ssSetSampleTime(childS, 0, 0.0);
35430 ssSetOffsetTime(childS, 0, 0.0);
35431 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
35432
35433 /* set compiled values of dynamic vector attributes */
35434 ssSetNumNonsampledZCs(childS, 0);
35435
35436 /* Update connectivity flags for each port */
35437 _ssSetInputPortConnected(childS, 0, 1);
35438 _ssSetInputPortConnected(childS, 1, 1);
35439 _ssSetInputPortConnected(childS, 2, 1);
35440 _ssSetInputPortConnected(childS, 3, 1);
35441 _ssSetInputPortConnected(childS, 4, 1);
35442 _ssSetOutputPortConnected(childS, 0, 1);
35443 _ssSetOutputPortConnected(childS, 1, 1);
35444 _ssSetOutputPortBeingMerged(childS, 0, 0);
35445 _ssSetOutputPortBeingMerged(childS, 1, 0);
35446
35447 /* Update the BufferDstPort flags for each input port */
35448 _ssSetInputPortBufferDstPort(childS, 0, -1);
35449 _ssSetInputPortBufferDstPort(childS, 1, -1);
35450 _ssSetInputPortBufferDstPort(childS, 2, -1);
35451 _ssSetInputPortBufferDstPort(childS, 3, -1);
35452 _ssSetInputPortBufferDstPort(childS, 4, -1);
35453 }
35454
35455 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S226>/Generated S-Function1 (SaturationLimiter_sf) */
35456 {
35457 SimStruct *childS = ssGetSFunction(rts, 134);
35458
35459 /* timing info */
35460 time_T *sfcnPeriod;
35461 time_T *sfcnOffset;
35462 int_T *sfcnTsMap;
35463 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
35464 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
35465 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
35466 ss_VALIDATE_MEMORY(rts,sfcnOffset);
35467 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
35468 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
35469 (void) memset((void*)sfcnPeriod, 0,
35470 sizeof(time_T)*1);
35471 (void) memset((void*)sfcnOffset, 0,
35472 sizeof(time_T)*1);
35473 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
35474 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
35475 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
35476
35477 /* Set up the mdlInfo pointer */
35478# ifdef USE_RTMODEL
35479
35480 {
35481 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
35482 struct _ssBlkInfo2));
35483 ss_VALIDATE_MEMORY(rts,blkInfo2);
35484 ssSetBlkInfo2Ptr(childS, blkInfo2);
35485 }
35486
35487 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
35488
35489# else
35490
35491 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
35492
35493# endif /* USE_RTMODEL */
35494
35495 /* Allocate memory of model methods 2 */
35496 {
35497 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
35498 malloc(sizeof(struct _ssSFcnModelMethods2));
35499 ss_VALIDATE_MEMORY(rts,methods2);
35500 ssSetModelMethods2(childS, methods2);
35501 }
35502
35503 /* Allocate memory of model methods 3 */
35504 {
35505 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
35506 malloc(sizeof(struct _ssSFcnModelMethods3));
35507 ss_VALIDATE_MEMORY(rts,methods3);
35508 ssSetModelMethods3(childS, methods3);
35509 }
35510
35511 /* Allocate memory for states auxilliary information */
35512 {
35513 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
35514 (sizeof(struct _ssStatesInfo2));
35515 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
35516 malloc(sizeof(ssPeriodicStatesInfo));
35517 ss_VALIDATE_MEMORY(rts,statesInfo2);
35518 ssSetStatesInfo2(childS, statesInfo2);
35519 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
35520 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
35521 }
35522
35523 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
35524 RegNumInputPorts);
35525 ssSetRegNumInputPortsFcnArg(childS,childS);
35526
35527 /* inputs */
35528 {
35529 struct _ssPortInputs *inputPortInfo =
35530 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
35531 ss_VALIDATE_MEMORY(rts,inputPortInfo);
35532 _ssSetNumInputPorts(childS, 3);
35533 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
35534
35535 /* port 0 */
35536 {
35537 real32_T const **sfcnUPtrs = (real32_T const **)
35538 malloc(1 * sizeof(real32_T *));
35539 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35540 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
35541 ssGetLocalBlockIO(rts))->Switch_c;
35542 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
35543 _ssSetInputPortNumDimensions(childS, 0, 1);
35544 ssSetInputPortWidth(childS, 0, 1);
35545 }
35546
35547 /* port 1 */
35548 {
35549 real32_T const **sfcnUPtrs = (real32_T const **)
35550 malloc(1 * sizeof(real32_T *));
35551 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35552 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled130;
35553 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
35554 _ssSetInputPortNumDimensions(childS, 1, 1);
35555 ssSetInputPortWidth(childS, 1, 1);
35556 }
35557
35558 /* port 2 */
35559 {
35560 real32_T const **sfcnUPtrs = (real32_T const **)
35561 malloc(1 * sizeof(real32_T *));
35562 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35563 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled131;
35564 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
35565 _ssSetInputPortNumDimensions(childS, 2, 1);
35566 ssSetInputPortWidth(childS, 2, 1);
35567 }
35568 }
35569
35570 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
35571 RegNumOutputPorts);
35572 ssSetRegNumOutputPortsFcnArg(childS,childS);
35573
35574 /* outputs */
35575 {
35576 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
35577 calloc(1, sizeof(struct _ssPortOutputs));
35578 ss_VALIDATE_MEMORY(rts,outputPortInfo);
35579 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
35580 _ssSetNumOutputPorts(childS, 1);
35581
35582 /* port 0 */
35583 {
35584 _ssSetOutputPortNumDimensions(childS, 0, 1);
35585 ssSetOutputPortWidth(childS, 0, 1);
35586 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
35587 ssGetLocalBlockIO(rts))->GeneratedSFunction1_or));
35588 }
35589 }
35590
35591 /* path info */
35592 _ssSetModelName(childS, "SaturationLimiter_sf");
35593 _ssSetPath(childS,
35594 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/Saturation Limiter4/Generated S-Function1");
35595 if (ssGetRTModel(rts) == (NULL)) {
35596 _ssSetParentSS(childS, rts);
35597 _ssSetRootSS(childS, ssGetRootSS(rts));
35598 } else {
35599 ssSetRTModel(childS,ssGetRTModel(rts));
35600 _ssSetParentSS(childS, (NULL));
35601 _ssSetRootSS(childS, childS);
35602 }
35603
35604 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
35605 (childS)->regDataType.arg1 = ((void *)(childS));
35606 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
35607 FcnSetErrorStatus);
35608 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
35609 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
35610 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
35611 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
35612
35613 /* registration */
35614#if defined(MATLAB_MEX_FILE)
35615
35616 {
35617 int_T i;
35618 mxArray *plhs[1];
35619 mxArray *prhs[4];
35620 double *pr;
35621 volatile int_T *intS = (int_T *)&childS;
35622 int_T addrlen = sizeof(SimStruct *);
35623 int_T m = addrlen/sizeof(int_T) + 1;
35624 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
35625 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
35626 pr = mxGetPr(prhs[1]);
35627 for (i = 0; i < m - 1; i++) {
35628 pr[i] = (double)intS[i];
35629 }
35630
35631 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
35632 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
35633 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
35634
35635 /* Reset port dimensions info functions because the S-function
35636 * and accelerator mex-files explicitly set their dimensions,
35637 * i.e., they are not dynamically sized. For this case, the
35638 * mex-file is responsible for the dimensions info memory
35639 * and Simulink should not free it. This is achieved by
35640 * setting the following two methods to NULL.
35641 */
35642 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
35643 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
35644
35645 /*
35646 * Setup function pointers and call mdlInitializeSizes via
35647 * simulink.c
35648 */
35649 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
35650 mxDestroyArray(plhs[0]);
35651 mxDestroyArray(prhs[0]);
35652 mxDestroyArray(prhs[1]);
35653 mxDestroyArray(prhs[2]);
35654 mxDestroyArray(prhs[3]);
35655 }
35656
35657#else
35658
35659 {
35660 SaturationLimiter_sf(childS);
35661 sfcnInitializeSizes(childS);
35662 }
35663
35664#endif
35665
35666 sfcnInitializeSampleTimes(childS);
35667
35668 /* adjust sample time */
35669 ssSetSampleTime(childS, 0, 0.0);
35670 ssSetOffsetTime(childS, 0, 0.0);
35671 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
35672
35673 /* set compiled values of dynamic vector attributes */
35674 ssSetNumNonsampledZCs(childS, 0);
35675
35676 /* Update connectivity flags for each port */
35677 _ssSetInputPortConnected(childS, 0, 1);
35678 _ssSetInputPortConnected(childS, 1, 1);
35679 _ssSetInputPortConnected(childS, 2, 1);
35680 _ssSetOutputPortConnected(childS, 0, 1);
35681 _ssSetOutputPortBeingMerged(childS, 0, 0);
35682
35683 /* Update the BufferDstPort flags for each input port */
35684 _ssSetInputPortBufferDstPort(childS, 0, -1);
35685 _ssSetInputPortBufferDstPort(childS, 1, -1);
35686 _ssSetInputPortBufferDstPort(childS, 2, -1);
35687 }
35688
35689 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S224>/Generated S-Function7 (RateLimiter_sf) */
35690 {
35691 SimStruct *childS = ssGetSFunction(rts, 135);
35692
35693 /* timing info */
35694 time_T *sfcnPeriod;
35695 time_T *sfcnOffset;
35696 int_T *sfcnTsMap;
35697 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
35698 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
35699 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
35700 ss_VALIDATE_MEMORY(rts,sfcnOffset);
35701 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
35702 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
35703 (void) memset((void*)sfcnPeriod, 0,
35704 sizeof(time_T)*1);
35705 (void) memset((void*)sfcnOffset, 0,
35706 sizeof(time_T)*1);
35707 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
35708 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
35709 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
35710
35711 /* Set up the mdlInfo pointer */
35712# ifdef USE_RTMODEL
35713
35714 {
35715 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
35716 struct _ssBlkInfo2));
35717 ss_VALIDATE_MEMORY(rts,blkInfo2);
35718 ssSetBlkInfo2Ptr(childS, blkInfo2);
35719 }
35720
35721 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
35722
35723# else
35724
35725 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
35726
35727# endif /* USE_RTMODEL */
35728
35729 /* Allocate memory of model methods 2 */
35730 {
35731 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
35732 malloc(sizeof(struct _ssSFcnModelMethods2));
35733 ss_VALIDATE_MEMORY(rts,methods2);
35734 ssSetModelMethods2(childS, methods2);
35735 }
35736
35737 /* Allocate memory of model methods 3 */
35738 {
35739 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
35740 malloc(sizeof(struct _ssSFcnModelMethods3));
35741 ss_VALIDATE_MEMORY(rts,methods3);
35742 ssSetModelMethods3(childS, methods3);
35743 }
35744
35745 /* Allocate memory for states auxilliary information */
35746 {
35747 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
35748 (sizeof(struct _ssStatesInfo2));
35749 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
35750 malloc(sizeof(ssPeriodicStatesInfo));
35751 ss_VALIDATE_MEMORY(rts,statesInfo2);
35752 ssSetStatesInfo2(childS, statesInfo2);
35753 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
35754 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
35755 }
35756
35757 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
35758 RegNumInputPorts);
35759 ssSetRegNumInputPortsFcnArg(childS,childS);
35760
35761 /* inputs */
35762 {
35763 struct _ssPortInputs *inputPortInfo =
35764 (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));
35765 ss_VALIDATE_MEMORY(rts,inputPortInfo);
35766 _ssSetNumInputPorts(childS, 5);
35767 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
35768
35769 /* port 0 */
35770 {
35771 int8_T const **sfcnUPtrs = (int8_T const **)
35772 malloc(1 * sizeof(int8_T *));
35773 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35774 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
35775 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
35776 _ssSetInputPortNumDimensions(childS, 0, 1);
35777 ssSetInputPortWidth(childS, 0, 1);
35778 }
35779
35780 /* port 1 */
35781 {
35782 real32_T const **sfcnUPtrs = (real32_T const **)
35783 malloc(1 * sizeof(real32_T *));
35784 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35785 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
35786 ssGetLocalBlockIO(rts))->Gain1_o;
35787 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
35788 _ssSetInputPortNumDimensions(childS, 1, 1);
35789 ssSetInputPortWidth(childS, 1, 1);
35790 }
35791
35792 /* port 2 */
35793 {
35794 real32_T const **sfcnUPtrs = (real32_T const **)
35795 malloc(1 * sizeof(real32_T *));
35796 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35797 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled125;
35798 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
35799 _ssSetInputPortNumDimensions(childS, 2, 1);
35800 ssSetInputPortWidth(childS, 2, 1);
35801 }
35802
35803 /* port 3 */
35804 {
35805 real32_T const **sfcnUPtrs = (real32_T const **)
35806 malloc(1 * sizeof(real32_T *));
35807 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35808 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
35809 ssGetLocalBlockIO(rts))->dtCAS;
35810 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
35811 _ssSetInputPortNumDimensions(childS, 3, 1);
35812 ssSetInputPortWidth(childS, 3, 1);
35813 }
35814
35815 /* port 4 */
35816 {
35817 real32_T const **sfcnUPtrs = (real32_T const **)
35818 malloc(1 * sizeof(real32_T *));
35819 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
35820 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
35821 ssGetLocalBlockIO(rts))->GeneratedSFunction1_or;
35822 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
35823 _ssSetInputPortNumDimensions(childS, 4, 1);
35824 ssSetInputPortWidth(childS, 4, 1);
35825 }
35826 }
35827
35828 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
35829 RegNumOutputPorts);
35830 ssSetRegNumOutputPortsFcnArg(childS,childS);
35831
35832 /* outputs */
35833 {
35834 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
35835 calloc(2, sizeof(struct _ssPortOutputs));
35836 ss_VALIDATE_MEMORY(rts,outputPortInfo);
35837 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
35838 _ssSetNumOutputPorts(childS, 2);
35839
35840 /* port 0 */
35841 {
35842 _ssSetOutputPortNumDimensions(childS, 0, 1);
35843 ssSetOutputPortWidth(childS, 0, 1);
35844 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
35845 ssGetLocalBlockIO(rts))->drint));
35846 }
35847
35848 /* port 1 */
35849 {
35850 _ssSetOutputPortNumDimensions(childS, 1, 1);
35851 ssSetOutputPortWidth(childS, 1, 1);
35852 _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)
35853 ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2_i));
35854 }
35855 }
35856
35857 /* path info */
35858 _ssSetModelName(childS, "RateLimiter_sf");
35859 _ssSetPath(childS,
35860 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/latTdaclda1/Rate Limiter3/Generated S-Function7");
35861 if (ssGetRTModel(rts) == (NULL)) {
35862 _ssSetParentSS(childS, rts);
35863 _ssSetRootSS(childS, ssGetRootSS(rts));
35864 } else {
35865 ssSetRTModel(childS,ssGetRTModel(rts));
35866 _ssSetParentSS(childS, (NULL));
35867 _ssSetRootSS(childS, childS);
35868 }
35869
35870 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
35871
35872 /* work vectors */
35873 {
35874 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
35875 (3 * sizeof(struct _ssDWorkRecord));
35876 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
35877 calloc(3, sizeof(struct _ssDWorkAuxRecord));
35878 ss_VALIDATE_MEMORY(rts,dWorkRecord);
35879 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
35880 ssSetSFcnDWork(childS, dWorkRecord);
35881 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
35882 _ssSetNumDWork(childS, 3);
35883
35884 /* DWORK0 */
35885 ssSetDWorkWidth(childS, 0, 1);
35886 ssSetDWorkDataType(childS, 0,SS_SINGLE);
35887 ssSetDWorkComplexSignal(childS, 0, 0);
35888 ssSetDWorkUsedAsDState(childS, 0, 1);
35889 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 250))[0]);
35890
35891 /* DWORK1 */
35892 ssSetDWorkWidth(childS, 1, 1);
35893 ssSetDWorkDataType(childS, 1,SS_INT8);
35894 ssSetDWorkComplexSignal(childS, 1, 0);
35895 ssSetDWorkUsedAsDState(childS, 1, 1);
35896 _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 479))[0]);
35897
35898 /* DWORK2 */
35899 ssSetDWorkWidth(childS, 2, 1);
35900 ssSetDWorkDataType(childS, 2,SS_INT8);
35901 ssSetDWorkComplexSignal(childS, 2, 0);
35902 ssSetDWorkUsedAsDState(childS, 2, 1);
35903 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 480))[0]);
35904 }
35905
35906 (childS)->regDataType.arg1 = ((void *)(childS));
35907 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
35908 FcnSetErrorStatus);
35909 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
35910 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
35911 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
35912 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
35913
35914 /* registration */
35915#if defined(MATLAB_MEX_FILE)
35916
35917 {
35918 int_T i;
35919 mxArray *plhs[1];
35920 mxArray *prhs[4];
35921 double *pr;
35922 volatile int_T *intS = (int_T *)&childS;
35923 int_T addrlen = sizeof(SimStruct *);
35924 int_T m = addrlen/sizeof(int_T) + 1;
35925 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
35926 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
35927 pr = mxGetPr(prhs[1]);
35928 for (i = 0; i < m - 1; i++) {
35929 pr[i] = (double)intS[i];
35930 }
35931
35932 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
35933 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
35934 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
35935
35936 /* Reset port dimensions info functions because the S-function
35937 * and accelerator mex-files explicitly set their dimensions,
35938 * i.e., they are not dynamically sized. For this case, the
35939 * mex-file is responsible for the dimensions info memory
35940 * and Simulink should not free it. This is achieved by
35941 * setting the following two methods to NULL.
35942 */
35943 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
35944 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
35945
35946 /*
35947 * Setup function pointers and call mdlInitializeSizes via
35948 * simulink.c
35949 */
35950 mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");
35951 mxDestroyArray(plhs[0]);
35952 mxDestroyArray(prhs[0]);
35953 mxDestroyArray(prhs[1]);
35954 mxDestroyArray(prhs[2]);
35955 mxDestroyArray(prhs[3]);
35956 }
35957
35958#else
35959
35960 {
35961 RateLimiter_sf(childS);
35962 sfcnInitializeSizes(childS);
35963 }
35964
35965#endif
35966
35967 sfcnInitializeSampleTimes(childS);
35968
35969 /* adjust sample time */
35970 ssSetSampleTime(childS, 0, 0.0);
35971 ssSetOffsetTime(childS, 0, 0.0);
35972 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
35973
35974 /* set compiled values of dynamic vector attributes */
35975 ssSetNumNonsampledZCs(childS, 0);
35976
35977 /* Update connectivity flags for each port */
35978 _ssSetInputPortConnected(childS, 0, 1);
35979 _ssSetInputPortConnected(childS, 1, 1);
35980 _ssSetInputPortConnected(childS, 2, 1);
35981 _ssSetInputPortConnected(childS, 3, 1);
35982 _ssSetInputPortConnected(childS, 4, 1);
35983 _ssSetOutputPortConnected(childS, 0, 1);
35984 _ssSetOutputPortConnected(childS, 1, 1);
35985 _ssSetOutputPortBeingMerged(childS, 0, 0);
35986 _ssSetOutputPortBeingMerged(childS, 1, 0);
35987
35988 /* Update the BufferDstPort flags for each input port */
35989 _ssSetInputPortBufferDstPort(childS, 0, -1);
35990 _ssSetInputPortBufferDstPort(childS, 1, -1);
35991 _ssSetInputPortBufferDstPort(childS, 2, -1);
35992 _ssSetInputPortBufferDstPort(childS, 3, -1);
35993 _ssSetInputPortBufferDstPort(childS, 4, -1);
35994 }
35995
35996 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S252>/Generated S-Function8 (WashoutFilter_sf) */
35997 {
35998 SimStruct *childS = ssGetSFunction(rts, 136);
35999
36000 /* timing info */
36001 time_T *sfcnPeriod;
36002 time_T *sfcnOffset;
36003 int_T *sfcnTsMap;
36004 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
36005 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
36006 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
36007 ss_VALIDATE_MEMORY(rts,sfcnOffset);
36008 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
36009 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
36010 (void) memset((void*)sfcnPeriod, 0,
36011 sizeof(time_T)*1);
36012 (void) memset((void*)sfcnOffset, 0,
36013 sizeof(time_T)*1);
36014 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
36015 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
36016 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
36017
36018 /* Set up the mdlInfo pointer */
36019# ifdef USE_RTMODEL
36020
36021 {
36022 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
36023 struct _ssBlkInfo2));
36024 ss_VALIDATE_MEMORY(rts,blkInfo2);
36025 ssSetBlkInfo2Ptr(childS, blkInfo2);
36026 }
36027
36028 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
36029
36030# else
36031
36032 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
36033
36034# endif /* USE_RTMODEL */
36035
36036 /* Allocate memory of model methods 2 */
36037 {
36038 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
36039 malloc(sizeof(struct _ssSFcnModelMethods2));
36040 ss_VALIDATE_MEMORY(rts,methods2);
36041 ssSetModelMethods2(childS, methods2);
36042 }
36043
36044 /* Allocate memory of model methods 3 */
36045 {
36046 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
36047 malloc(sizeof(struct _ssSFcnModelMethods3));
36048 ss_VALIDATE_MEMORY(rts,methods3);
36049 ssSetModelMethods3(childS, methods3);
36050 }
36051
36052 /* Allocate memory for states auxilliary information */
36053 {
36054 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
36055 (sizeof(struct _ssStatesInfo2));
36056 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
36057 malloc(sizeof(ssPeriodicStatesInfo));
36058 ss_VALIDATE_MEMORY(rts,statesInfo2);
36059 ssSetStatesInfo2(childS, statesInfo2);
36060 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
36061 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
36062 }
36063
36064 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
36065 RegNumInputPorts);
36066 ssSetRegNumInputPortsFcnArg(childS,childS);
36067
36068 /* inputs */
36069 {
36070 struct _ssPortInputs *inputPortInfo =
36071 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
36072 ss_VALIDATE_MEMORY(rts,inputPortInfo);
36073 _ssSetNumInputPorts(childS, 6);
36074 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
36075
36076 /* port 0 */
36077 {
36078 real32_T const **sfcnUPtrs = (real32_T const **)
36079 malloc(1 * sizeof(real32_T *));
36080 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36081 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36082 ssGetLocalBlockIO(rts))->dtCAS;
36083 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
36084 _ssSetInputPortNumDimensions(childS, 0, 1);
36085 ssSetInputPortWidth(childS, 0, 1);
36086 }
36087
36088 /* port 1 */
36089 {
36090 int8_T const **sfcnUPtrs = (int8_T const **)
36091 malloc(1 * sizeof(int8_T *));
36092 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36093 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
36094 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
36095 _ssSetInputPortNumDimensions(childS, 1, 1);
36096 ssSetInputPortWidth(childS, 1, 1);
36097 }
36098
36099 /* port 2 */
36100 {
36101 real32_T const **sfcnUPtrs = (real32_T const **)
36102 malloc(1 * sizeof(real32_T *));
36103 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36104 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
36105 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
36106 _ssSetInputPortNumDimensions(childS, 2, 1);
36107 ssSetInputPortWidth(childS, 2, 1);
36108 }
36109
36110 /* port 3 */
36111 {
36112 real32_T const **sfcnUPtrs = (real32_T const **)
36113 malloc(1 * sizeof(real32_T *));
36114 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36115 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36116 ssGetLocalBlockIO(rts))->q_k;
36117 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
36118 _ssSetInputPortNumDimensions(childS, 3, 1);
36119 ssSetInputPortWidth(childS, 3, 1);
36120 }
36121
36122 /* port 4 */
36123 {
36124 real32_T const **sfcnUPtrs = (real32_T const **)
36125 malloc(1 * sizeof(real32_T *));
36126 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36127 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36128 ssGetLocalBlockIO(rts))->q_k;
36129 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
36130 _ssSetInputPortNumDimensions(childS, 4, 1);
36131 ssSetInputPortWidth(childS, 4, 1);
36132 }
36133
36134 /* port 5 */
36135 {
36136 real32_T const **sfcnUPtrs = (real32_T const **)
36137 malloc(1 * sizeof(real32_T *));
36138 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36139 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36140 ssGetLocalBlockIO(rts))->q_k;
36141 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
36142 _ssSetInputPortNumDimensions(childS, 5, 1);
36143 ssSetInputPortWidth(childS, 5, 1);
36144 }
36145 }
36146
36147 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
36148 RegNumOutputPorts);
36149 ssSetRegNumOutputPortsFcnArg(childS,childS);
36150
36151 /* outputs */
36152 {
36153 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
36154 calloc(1, sizeof(struct _ssPortOutputs));
36155 ss_VALIDATE_MEMORY(rts,outputPortInfo);
36156 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
36157 _ssSetNumOutputPorts(childS, 1);
36158
36159 /* port 0 */
36160 {
36161 _ssSetOutputPortNumDimensions(childS, 0, 1);
36162 ssSetOutputPortWidth(childS, 0, 1);
36163 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
36164 ssGetLocalBlockIO(rts))->GeneratedSFunction8_p));
36165 }
36166 }
36167
36168 /* path info */
36169 _ssSetModelName(childS, "WashoutFilter_sf");
36170 _ssSetPath(childS,
36171 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/ high pass filter/Generated S-Function8");
36172 if (ssGetRTModel(rts) == (NULL)) {
36173 _ssSetParentSS(childS, rts);
36174 _ssSetRootSS(childS, ssGetRootSS(rts));
36175 } else {
36176 ssSetRTModel(childS,ssGetRTModel(rts));
36177 _ssSetParentSS(childS, (NULL));
36178 _ssSetRootSS(childS, childS);
36179 }
36180
36181 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
36182
36183 /* work vectors */
36184 {
36185 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
36186 (4 * sizeof(struct _ssDWorkRecord));
36187 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
36188 calloc(4, sizeof(struct _ssDWorkAuxRecord));
36189 ss_VALIDATE_MEMORY(rts,dWorkRecord);
36190 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
36191 ssSetSFcnDWork(childS, dWorkRecord);
36192 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
36193 _ssSetNumDWork(childS, 4);
36194
36195 /* DWORK0 */
36196 ssSetDWorkWidth(childS, 0, 1);
36197 ssSetDWorkDataType(childS, 0,SS_SINGLE);
36198 ssSetDWorkComplexSignal(childS, 0, 0);
36199 ssSetDWorkUsedAsDState(childS, 0, 1);
36200 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 251))[0]);
36201
36202 /* DWORK1 */
36203 ssSetDWorkWidth(childS, 1, 1);
36204 ssSetDWorkDataType(childS, 1,SS_SINGLE);
36205 ssSetDWorkComplexSignal(childS, 1, 0);
36206 ssSetDWorkUsedAsDState(childS, 1, 1);
36207 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 252))[0]);
36208
36209 /* DWORK2 */
36210 ssSetDWorkWidth(childS, 2, 1);
36211 ssSetDWorkDataType(childS, 2,SS_INT8);
36212 ssSetDWorkComplexSignal(childS, 2, 0);
36213 ssSetDWorkUsedAsDState(childS, 2, 1);
36214 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 481))[0]);
36215
36216 /* DWORK3 */
36217 ssSetDWorkWidth(childS, 3, 1);
36218 ssSetDWorkDataType(childS, 3,SS_INT8);
36219 ssSetDWorkComplexSignal(childS, 3, 0);
36220 ssSetDWorkUsedAsDState(childS, 3, 1);
36221 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 482))[0]);
36222 }
36223
36224 (childS)->regDataType.arg1 = ((void *)(childS));
36225 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
36226 FcnSetErrorStatus);
36227 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
36228 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
36229 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
36230 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
36231
36232 /* registration */
36233#if defined(MATLAB_MEX_FILE)
36234
36235 {
36236 int_T i;
36237 mxArray *plhs[1];
36238 mxArray *prhs[4];
36239 double *pr;
36240 volatile int_T *intS = (int_T *)&childS;
36241 int_T addrlen = sizeof(SimStruct *);
36242 int_T m = addrlen/sizeof(int_T) + 1;
36243 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
36244 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
36245 pr = mxGetPr(prhs[1]);
36246 for (i = 0; i < m - 1; i++) {
36247 pr[i] = (double)intS[i];
36248 }
36249
36250 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
36251 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
36252 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
36253
36254 /* Reset port dimensions info functions because the S-function
36255 * and accelerator mex-files explicitly set their dimensions,
36256 * i.e., they are not dynamically sized. For this case, the
36257 * mex-file is responsible for the dimensions info memory
36258 * and Simulink should not free it. This is achieved by
36259 * setting the following two methods to NULL.
36260 */
36261 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
36262 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
36263
36264 /*
36265 * Setup function pointers and call mdlInitializeSizes via
36266 * simulink.c
36267 */
36268 mexCallMATLAB(1, plhs, 4, prhs, "WashoutFilter_sf");
36269 mxDestroyArray(plhs[0]);
36270 mxDestroyArray(prhs[0]);
36271 mxDestroyArray(prhs[1]);
36272 mxDestroyArray(prhs[2]);
36273 mxDestroyArray(prhs[3]);
36274 }
36275
36276#else
36277
36278 {
36279 WashoutFilter_sf(childS);
36280 sfcnInitializeSizes(childS);
36281 }
36282
36283#endif
36284
36285 sfcnInitializeSampleTimes(childS);
36286
36287 /* adjust sample time */
36288 ssSetSampleTime(childS, 0, 0.0);
36289 ssSetOffsetTime(childS, 0, 0.0);
36290 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
36291
36292 /* set compiled values of dynamic vector attributes */
36293 ssSetNumNonsampledZCs(childS, 0);
36294
36295 /* Update connectivity flags for each port */
36296 _ssSetInputPortConnected(childS, 0, 1);
36297 _ssSetInputPortConnected(childS, 1, 1);
36298 _ssSetInputPortConnected(childS, 2, 1);
36299 _ssSetInputPortConnected(childS, 3, 1);
36300 _ssSetInputPortConnected(childS, 4, 1);
36301 _ssSetInputPortConnected(childS, 5, 1);
36302 _ssSetOutputPortConnected(childS, 0, 1);
36303 _ssSetOutputPortBeingMerged(childS, 0, 0);
36304
36305 /* Update the BufferDstPort flags for each input port */
36306 _ssSetInputPortBufferDstPort(childS, 0, -1);
36307 _ssSetInputPortBufferDstPort(childS, 1, -1);
36308 _ssSetInputPortBufferDstPort(childS, 2, -1);
36309 _ssSetInputPortBufferDstPort(childS, 3, -1);
36310 _ssSetInputPortBufferDstPort(childS, 4, -1);
36311 _ssSetInputPortBufferDstPort(childS, 5, -1);
36312 }
36313
36314 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S253>/Generated S-Function4 (LagFilter_sf) */
36315 {
36316 SimStruct *childS = ssGetSFunction(rts, 137);
36317
36318 /* timing info */
36319 time_T *sfcnPeriod;
36320 time_T *sfcnOffset;
36321 int_T *sfcnTsMap;
36322 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
36323 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
36324 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
36325 ss_VALIDATE_MEMORY(rts,sfcnOffset);
36326 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
36327 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
36328 (void) memset((void*)sfcnPeriod, 0,
36329 sizeof(time_T)*1);
36330 (void) memset((void*)sfcnOffset, 0,
36331 sizeof(time_T)*1);
36332 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
36333 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
36334 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
36335
36336 /* Set up the mdlInfo pointer */
36337# ifdef USE_RTMODEL
36338
36339 {
36340 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
36341 struct _ssBlkInfo2));
36342 ss_VALIDATE_MEMORY(rts,blkInfo2);
36343 ssSetBlkInfo2Ptr(childS, blkInfo2);
36344 }
36345
36346 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
36347
36348# else
36349
36350 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
36351
36352# endif /* USE_RTMODEL */
36353
36354 /* Allocate memory of model methods 2 */
36355 {
36356 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
36357 malloc(sizeof(struct _ssSFcnModelMethods2));
36358 ss_VALIDATE_MEMORY(rts,methods2);
36359 ssSetModelMethods2(childS, methods2);
36360 }
36361
36362 /* Allocate memory of model methods 3 */
36363 {
36364 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
36365 malloc(sizeof(struct _ssSFcnModelMethods3));
36366 ss_VALIDATE_MEMORY(rts,methods3);
36367 ssSetModelMethods3(childS, methods3);
36368 }
36369
36370 /* Allocate memory for states auxilliary information */
36371 {
36372 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
36373 (sizeof(struct _ssStatesInfo2));
36374 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
36375 malloc(sizeof(ssPeriodicStatesInfo));
36376 ss_VALIDATE_MEMORY(rts,statesInfo2);
36377 ssSetStatesInfo2(childS, statesInfo2);
36378 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
36379 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
36380 }
36381
36382 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
36383 RegNumInputPorts);
36384 ssSetRegNumInputPortsFcnArg(childS,childS);
36385
36386 /* inputs */
36387 {
36388 struct _ssPortInputs *inputPortInfo =
36389 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
36390 ss_VALIDATE_MEMORY(rts,inputPortInfo);
36391 _ssSetNumInputPorts(childS, 6);
36392 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
36393
36394 /* port 0 */
36395 {
36396 real32_T const **sfcnUPtrs = (real32_T const **)
36397 malloc(1 * sizeof(real32_T *));
36398 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36399 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36400 ssGetLocalBlockIO(rts))->dtCAS;
36401 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
36402 _ssSetInputPortNumDimensions(childS, 0, 1);
36403 ssSetInputPortWidth(childS, 0, 1);
36404 }
36405
36406 /* port 1 */
36407 {
36408 int8_T const **sfcnUPtrs = (int8_T const **)
36409 malloc(1 * sizeof(int8_T *));
36410 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36411 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
36412 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
36413 _ssSetInputPortNumDimensions(childS, 1, 1);
36414 ssSetInputPortWidth(childS, 1, 1);
36415 }
36416
36417 /* port 2 */
36418 {
36419 real32_T const **sfcnUPtrs = (real32_T const **)
36420 malloc(1 * sizeof(real32_T *));
36421 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36422 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled114;
36423 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
36424 _ssSetInputPortNumDimensions(childS, 2, 1);
36425 ssSetInputPortWidth(childS, 2, 1);
36426 }
36427
36428 /* port 3 */
36429 {
36430 real32_T const **sfcnUPtrs = (real32_T const **)
36431 malloc(1 * sizeof(real32_T *));
36432 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36433 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36434 ssGetLocalBlockIO(rts))->Sum1_e;
36435 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
36436 _ssSetInputPortNumDimensions(childS, 3, 1);
36437 ssSetInputPortWidth(childS, 3, 1);
36438 }
36439
36440 /* port 4 */
36441 {
36442 real32_T const **sfcnUPtrs = (real32_T const **)
36443 malloc(1 * sizeof(real32_T *));
36444 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36445 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36446 ssGetLocalBlockIO(rts))->Sum1_e;
36447 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
36448 _ssSetInputPortNumDimensions(childS, 4, 1);
36449 ssSetInputPortWidth(childS, 4, 1);
36450 }
36451
36452 /* port 5 */
36453 {
36454 real32_T const **sfcnUPtrs = (real32_T const **)
36455 malloc(1 * sizeof(real32_T *));
36456 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36457 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36458 ssGetLocalBlockIO(rts))->Sum1_e;
36459 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
36460 _ssSetInputPortNumDimensions(childS, 5, 1);
36461 ssSetInputPortWidth(childS, 5, 1);
36462 }
36463 }
36464
36465 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
36466 RegNumOutputPorts);
36467 ssSetRegNumOutputPortsFcnArg(childS,childS);
36468
36469 /* outputs */
36470 {
36471 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
36472 calloc(1, sizeof(struct _ssPortOutputs));
36473 ss_VALIDATE_MEMORY(rts,outputPortInfo);
36474 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
36475 _ssSetNumOutputPorts(childS, 1);
36476
36477 /* port 0 */
36478 {
36479 _ssSetOutputPortNumDimensions(childS, 0, 1);
36480 ssSetOutputPortWidth(childS, 0, 1);
36481 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
36482 ssGetLocalBlockIO(rts))->GeneratedSFunction4_e));
36483 }
36484 }
36485
36486 /* path info */
36487 _ssSetModelName(childS, "LagFilter_sf");
36488 _ssSetPath(childS,
36489 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/ lag filter/Generated S-Function4");
36490 if (ssGetRTModel(rts) == (NULL)) {
36491 _ssSetParentSS(childS, rts);
36492 _ssSetRootSS(childS, ssGetRootSS(rts));
36493 } else {
36494 ssSetRTModel(childS,ssGetRTModel(rts));
36495 _ssSetParentSS(childS, (NULL));
36496 _ssSetRootSS(childS, childS);
36497 }
36498
36499 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
36500
36501 /* work vectors */
36502 {
36503 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
36504 (4 * sizeof(struct _ssDWorkRecord));
36505 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
36506 calloc(4, sizeof(struct _ssDWorkAuxRecord));
36507 ss_VALIDATE_MEMORY(rts,dWorkRecord);
36508 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
36509 ssSetSFcnDWork(childS, dWorkRecord);
36510 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
36511 _ssSetNumDWork(childS, 4);
36512
36513 /* DWORK0 */
36514 ssSetDWorkWidth(childS, 0, 1);
36515 ssSetDWorkDataType(childS, 0,SS_SINGLE);
36516 ssSetDWorkComplexSignal(childS, 0, 0);
36517 ssSetDWorkUsedAsDState(childS, 0, 1);
36518 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 253))[0]);
36519
36520 /* DWORK1 */
36521 ssSetDWorkWidth(childS, 1, 1);
36522 ssSetDWorkDataType(childS, 1,SS_SINGLE);
36523 ssSetDWorkComplexSignal(childS, 1, 0);
36524 ssSetDWorkUsedAsDState(childS, 1, 1);
36525 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 254))[0]);
36526
36527 /* DWORK2 */
36528 ssSetDWorkWidth(childS, 2, 1);
36529 ssSetDWorkDataType(childS, 2,SS_INT8);
36530 ssSetDWorkComplexSignal(childS, 2, 0);
36531 ssSetDWorkUsedAsDState(childS, 2, 1);
36532 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 483))[0]);
36533
36534 /* DWORK3 */
36535 ssSetDWorkWidth(childS, 3, 1);
36536 ssSetDWorkDataType(childS, 3,SS_INT8);
36537 ssSetDWorkComplexSignal(childS, 3, 0);
36538 ssSetDWorkUsedAsDState(childS, 3, 1);
36539 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 484))[0]);
36540 }
36541
36542 (childS)->regDataType.arg1 = ((void *)(childS));
36543 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
36544 FcnSetErrorStatus);
36545 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
36546 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
36547 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
36548 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
36549
36550 /* registration */
36551#if defined(MATLAB_MEX_FILE)
36552
36553 {
36554 int_T i;
36555 mxArray *plhs[1];
36556 mxArray *prhs[4];
36557 double *pr;
36558 volatile int_T *intS = (int_T *)&childS;
36559 int_T addrlen = sizeof(SimStruct *);
36560 int_T m = addrlen/sizeof(int_T) + 1;
36561 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
36562 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
36563 pr = mxGetPr(prhs[1]);
36564 for (i = 0; i < m - 1; i++) {
36565 pr[i] = (double)intS[i];
36566 }
36567
36568 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
36569 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
36570 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
36571
36572 /* Reset port dimensions info functions because the S-function
36573 * and accelerator mex-files explicitly set their dimensions,
36574 * i.e., they are not dynamically sized. For this case, the
36575 * mex-file is responsible for the dimensions info memory
36576 * and Simulink should not free it. This is achieved by
36577 * setting the following two methods to NULL.
36578 */
36579 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
36580 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
36581
36582 /*
36583 * Setup function pointers and call mdlInitializeSizes via
36584 * simulink.c
36585 */
36586 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
36587 mxDestroyArray(plhs[0]);
36588 mxDestroyArray(prhs[0]);
36589 mxDestroyArray(prhs[1]);
36590 mxDestroyArray(prhs[2]);
36591 mxDestroyArray(prhs[3]);
36592 }
36593
36594#else
36595
36596 {
36597 LagFilter_sf(childS);
36598 sfcnInitializeSizes(childS);
36599 }
36600
36601#endif
36602
36603 sfcnInitializeSampleTimes(childS);
36604
36605 /* adjust sample time */
36606 ssSetSampleTime(childS, 0, 0.0);
36607 ssSetOffsetTime(childS, 0, 0.0);
36608 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
36609
36610 /* set compiled values of dynamic vector attributes */
36611 ssSetNumNonsampledZCs(childS, 0);
36612
36613 /* Update connectivity flags for each port */
36614 _ssSetInputPortConnected(childS, 0, 1);
36615 _ssSetInputPortConnected(childS, 1, 1);
36616 _ssSetInputPortConnected(childS, 2, 1);
36617 _ssSetInputPortConnected(childS, 3, 1);
36618 _ssSetInputPortConnected(childS, 4, 1);
36619 _ssSetInputPortConnected(childS, 5, 1);
36620 _ssSetOutputPortConnected(childS, 0, 1);
36621 _ssSetOutputPortBeingMerged(childS, 0, 0);
36622
36623 /* Update the BufferDstPort flags for each input port */
36624 _ssSetInputPortBufferDstPort(childS, 0, -1);
36625 _ssSetInputPortBufferDstPort(childS, 1, -1);
36626 _ssSetInputPortBufferDstPort(childS, 2, -1);
36627 _ssSetInputPortBufferDstPort(childS, 3, -1);
36628 _ssSetInputPortBufferDstPort(childS, 4, -1);
36629 _ssSetInputPortBufferDstPort(childS, 5, -1);
36630 }
36631
36632 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S254>/Generated S-Function4 (LagFilter_sf) */
36633 {
36634 SimStruct *childS = ssGetSFunction(rts, 138);
36635
36636 /* timing info */
36637 time_T *sfcnPeriod;
36638 time_T *sfcnOffset;
36639 int_T *sfcnTsMap;
36640 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
36641 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
36642 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
36643 ss_VALIDATE_MEMORY(rts,sfcnOffset);
36644 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
36645 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
36646 (void) memset((void*)sfcnPeriod, 0,
36647 sizeof(time_T)*1);
36648 (void) memset((void*)sfcnOffset, 0,
36649 sizeof(time_T)*1);
36650 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
36651 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
36652 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
36653
36654 /* Set up the mdlInfo pointer */
36655# ifdef USE_RTMODEL
36656
36657 {
36658 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
36659 struct _ssBlkInfo2));
36660 ss_VALIDATE_MEMORY(rts,blkInfo2);
36661 ssSetBlkInfo2Ptr(childS, blkInfo2);
36662 }
36663
36664 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
36665
36666# else
36667
36668 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
36669
36670# endif /* USE_RTMODEL */
36671
36672 /* Allocate memory of model methods 2 */
36673 {
36674 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
36675 malloc(sizeof(struct _ssSFcnModelMethods2));
36676 ss_VALIDATE_MEMORY(rts,methods2);
36677 ssSetModelMethods2(childS, methods2);
36678 }
36679
36680 /* Allocate memory of model methods 3 */
36681 {
36682 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
36683 malloc(sizeof(struct _ssSFcnModelMethods3));
36684 ss_VALIDATE_MEMORY(rts,methods3);
36685 ssSetModelMethods3(childS, methods3);
36686 }
36687
36688 /* Allocate memory for states auxilliary information */
36689 {
36690 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
36691 (sizeof(struct _ssStatesInfo2));
36692 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
36693 malloc(sizeof(ssPeriodicStatesInfo));
36694 ss_VALIDATE_MEMORY(rts,statesInfo2);
36695 ssSetStatesInfo2(childS, statesInfo2);
36696 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
36697 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
36698 }
36699
36700 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
36701 RegNumInputPorts);
36702 ssSetRegNumInputPortsFcnArg(childS,childS);
36703
36704 /* inputs */
36705 {
36706 struct _ssPortInputs *inputPortInfo =
36707 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
36708 ss_VALIDATE_MEMORY(rts,inputPortInfo);
36709 _ssSetNumInputPorts(childS, 6);
36710 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
36711
36712 /* port 0 */
36713 {
36714 real32_T const **sfcnUPtrs = (real32_T const **)
36715 malloc(1 * sizeof(real32_T *));
36716 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36717 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36718 ssGetLocalBlockIO(rts))->dtCAS;
36719 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
36720 _ssSetInputPortNumDimensions(childS, 0, 1);
36721 ssSetInputPortWidth(childS, 0, 1);
36722 }
36723
36724 /* port 1 */
36725 {
36726 int8_T const **sfcnUPtrs = (int8_T const **)
36727 malloc(1 * sizeof(int8_T *));
36728 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36729 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
36730 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
36731 _ssSetInputPortNumDimensions(childS, 1, 1);
36732 ssSetInputPortWidth(childS, 1, 1);
36733 }
36734
36735 /* port 2 */
36736 {
36737 real32_T const **sfcnUPtrs = (real32_T const **)
36738 malloc(1 * sizeof(real32_T *));
36739 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36740 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled113;
36741 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
36742 _ssSetInputPortNumDimensions(childS, 2, 1);
36743 ssSetInputPortWidth(childS, 2, 1);
36744 }
36745
36746 /* port 3 */
36747 {
36748 real32_T const **sfcnUPtrs = (real32_T const **)
36749 malloc(1 * sizeof(real32_T *));
36750 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36751 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36752 ssGetLocalBlockIO(rts))->q_k;
36753 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
36754 _ssSetInputPortNumDimensions(childS, 3, 1);
36755 ssSetInputPortWidth(childS, 3, 1);
36756 }
36757
36758 /* port 4 */
36759 {
36760 real32_T const **sfcnUPtrs = (real32_T const **)
36761 malloc(1 * sizeof(real32_T *));
36762 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36763 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36764 ssGetLocalBlockIO(rts))->q_k;
36765 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
36766 _ssSetInputPortNumDimensions(childS, 4, 1);
36767 ssSetInputPortWidth(childS, 4, 1);
36768 }
36769
36770 /* port 5 */
36771 {
36772 real32_T const **sfcnUPtrs = (real32_T const **)
36773 malloc(1 * sizeof(real32_T *));
36774 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
36775 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
36776 ssGetLocalBlockIO(rts))->q_k;
36777 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
36778 _ssSetInputPortNumDimensions(childS, 5, 1);
36779 ssSetInputPortWidth(childS, 5, 1);
36780 }
36781 }
36782
36783 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
36784 RegNumOutputPorts);
36785 ssSetRegNumOutputPortsFcnArg(childS,childS);
36786
36787 /* outputs */
36788 {
36789 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
36790 calloc(1, sizeof(struct _ssPortOutputs));
36791 ss_VALIDATE_MEMORY(rts,outputPortInfo);
36792 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
36793 _ssSetNumOutputPorts(childS, 1);
36794
36795 /* port 0 */
36796 {
36797 _ssSetOutputPortNumDimensions(childS, 0, 1);
36798 ssSetOutputPortWidth(childS, 0, 1);
36799 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
36800 ssGetLocalBlockIO(rts))->GeneratedSFunction4_ms));
36801 }
36802 }
36803
36804 /* path info */
36805 _ssSetModelName(childS, "LagFilter_sf");
36806 _ssSetPath(childS,
36807 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/ lag filter1/Generated S-Function4");
36808 if (ssGetRTModel(rts) == (NULL)) {
36809 _ssSetParentSS(childS, rts);
36810 _ssSetRootSS(childS, ssGetRootSS(rts));
36811 } else {
36812 ssSetRTModel(childS,ssGetRTModel(rts));
36813 _ssSetParentSS(childS, (NULL));
36814 _ssSetRootSS(childS, childS);
36815 }
36816
36817 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
36818
36819 /* work vectors */
36820 {
36821 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
36822 (4 * sizeof(struct _ssDWorkRecord));
36823 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
36824 calloc(4, sizeof(struct _ssDWorkAuxRecord));
36825 ss_VALIDATE_MEMORY(rts,dWorkRecord);
36826 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
36827 ssSetSFcnDWork(childS, dWorkRecord);
36828 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
36829 _ssSetNumDWork(childS, 4);
36830
36831 /* DWORK0 */
36832 ssSetDWorkWidth(childS, 0, 1);
36833 ssSetDWorkDataType(childS, 0,SS_SINGLE);
36834 ssSetDWorkComplexSignal(childS, 0, 0);
36835 ssSetDWorkUsedAsDState(childS, 0, 1);
36836 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 255))[0]);
36837
36838 /* DWORK1 */
36839 ssSetDWorkWidth(childS, 1, 1);
36840 ssSetDWorkDataType(childS, 1,SS_SINGLE);
36841 ssSetDWorkComplexSignal(childS, 1, 0);
36842 ssSetDWorkUsedAsDState(childS, 1, 1);
36843 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 256))[0]);
36844
36845 /* DWORK2 */
36846 ssSetDWorkWidth(childS, 2, 1);
36847 ssSetDWorkDataType(childS, 2,SS_INT8);
36848 ssSetDWorkComplexSignal(childS, 2, 0);
36849 ssSetDWorkUsedAsDState(childS, 2, 1);
36850 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 485))[0]);
36851
36852 /* DWORK3 */
36853 ssSetDWorkWidth(childS, 3, 1);
36854 ssSetDWorkDataType(childS, 3,SS_INT8);
36855 ssSetDWorkComplexSignal(childS, 3, 0);
36856 ssSetDWorkUsedAsDState(childS, 3, 1);
36857 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 486))[0]);
36858 }
36859
36860 (childS)->regDataType.arg1 = ((void *)(childS));
36861 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
36862 FcnSetErrorStatus);
36863 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
36864 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
36865 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
36866 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
36867
36868 /* registration */
36869#if defined(MATLAB_MEX_FILE)
36870
36871 {
36872 int_T i;
36873 mxArray *plhs[1];
36874 mxArray *prhs[4];
36875 double *pr;
36876 volatile int_T *intS = (int_T *)&childS;
36877 int_T addrlen = sizeof(SimStruct *);
36878 int_T m = addrlen/sizeof(int_T) + 1;
36879 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
36880 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
36881 pr = mxGetPr(prhs[1]);
36882 for (i = 0; i < m - 1; i++) {
36883 pr[i] = (double)intS[i];
36884 }
36885
36886 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
36887 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
36888 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
36889
36890 /* Reset port dimensions info functions because the S-function
36891 * and accelerator mex-files explicitly set their dimensions,
36892 * i.e., they are not dynamically sized. For this case, the
36893 * mex-file is responsible for the dimensions info memory
36894 * and Simulink should not free it. This is achieved by
36895 * setting the following two methods to NULL.
36896 */
36897 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
36898 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
36899
36900 /*
36901 * Setup function pointers and call mdlInitializeSizes via
36902 * simulink.c
36903 */
36904 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
36905 mxDestroyArray(plhs[0]);
36906 mxDestroyArray(prhs[0]);
36907 mxDestroyArray(prhs[1]);
36908 mxDestroyArray(prhs[2]);
36909 mxDestroyArray(prhs[3]);
36910 }
36911
36912#else
36913
36914 {
36915 LagFilter_sf(childS);
36916 sfcnInitializeSizes(childS);
36917 }
36918
36919#endif
36920
36921 sfcnInitializeSampleTimes(childS);
36922
36923 /* adjust sample time */
36924 ssSetSampleTime(childS, 0, 0.0);
36925 ssSetOffsetTime(childS, 0, 0.0);
36926 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
36927
36928 /* set compiled values of dynamic vector attributes */
36929 ssSetNumNonsampledZCs(childS, 0);
36930
36931 /* Update connectivity flags for each port */
36932 _ssSetInputPortConnected(childS, 0, 1);
36933 _ssSetInputPortConnected(childS, 1, 1);
36934 _ssSetInputPortConnected(childS, 2, 1);
36935 _ssSetInputPortConnected(childS, 3, 1);
36936 _ssSetInputPortConnected(childS, 4, 1);
36937 _ssSetInputPortConnected(childS, 5, 1);
36938 _ssSetOutputPortConnected(childS, 0, 1);
36939 _ssSetOutputPortBeingMerged(childS, 0, 0);
36940
36941 /* Update the BufferDstPort flags for each input port */
36942 _ssSetInputPortBufferDstPort(childS, 0, -1);
36943 _ssSetInputPortBufferDstPort(childS, 1, -1);
36944 _ssSetInputPortBufferDstPort(childS, 2, -1);
36945 _ssSetInputPortBufferDstPort(childS, 3, -1);
36946 _ssSetInputPortBufferDstPort(childS, 4, -1);
36947 _ssSetInputPortBufferDstPort(childS, 5, -1);
36948 }
36949
36950 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S259>/Generated S-Function (Gain_sf) */
36951 {
36952 SimStruct *childS = ssGetSFunction(rts, 139);
36953
36954 /* timing info */
36955 time_T *sfcnPeriod;
36956 time_T *sfcnOffset;
36957 int_T *sfcnTsMap;
36958 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
36959 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
36960 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
36961 ss_VALIDATE_MEMORY(rts,sfcnOffset);
36962 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
36963 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
36964 (void) memset((void*)sfcnPeriod, 0,
36965 sizeof(time_T)*1);
36966 (void) memset((void*)sfcnOffset, 0,
36967 sizeof(time_T)*1);
36968 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
36969 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
36970 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
36971
36972 /* Set up the mdlInfo pointer */
36973# ifdef USE_RTMODEL
36974
36975 {
36976 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
36977 struct _ssBlkInfo2));
36978 ss_VALIDATE_MEMORY(rts,blkInfo2);
36979 ssSetBlkInfo2Ptr(childS, blkInfo2);
36980 }
36981
36982 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
36983
36984# else
36985
36986 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
36987
36988# endif /* USE_RTMODEL */
36989
36990 /* Allocate memory of model methods 2 */
36991 {
36992 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
36993 malloc(sizeof(struct _ssSFcnModelMethods2));
36994 ss_VALIDATE_MEMORY(rts,methods2);
36995 ssSetModelMethods2(childS, methods2);
36996 }
36997
36998 /* Allocate memory of model methods 3 */
36999 {
37000 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
37001 malloc(sizeof(struct _ssSFcnModelMethods3));
37002 ss_VALIDATE_MEMORY(rts,methods3);
37003 ssSetModelMethods3(childS, methods3);
37004 }
37005
37006 /* Allocate memory for states auxilliary information */
37007 {
37008 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
37009 (sizeof(struct _ssStatesInfo2));
37010 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
37011 malloc(sizeof(ssPeriodicStatesInfo));
37012 ss_VALIDATE_MEMORY(rts,statesInfo2);
37013 ssSetStatesInfo2(childS, statesInfo2);
37014 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
37015 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
37016 }
37017
37018 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
37019 RegNumInputPorts);
37020 ssSetRegNumInputPortsFcnArg(childS,childS);
37021
37022 /* inputs */
37023 {
37024 struct _ssPortInputs *inputPortInfo =
37025 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
37026 ss_VALIDATE_MEMORY(rts,inputPortInfo);
37027 _ssSetNumInputPorts(childS, 2);
37028 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
37029
37030 /* port 0 */
37031 {
37032 real32_T const **sfcnUPtrs = (real32_T const **)
37033 malloc(1 * sizeof(real32_T *));
37034 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37035 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
37036 ssGetLocalBlockIO(rts))->GeneratedSFunction4_e;
37037 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
37038 _ssSetInputPortNumDimensions(childS, 0, 1);
37039 ssSetInputPortWidth(childS, 0, 1);
37040 }
37041
37042 /* port 1 */
37043 {
37044 real32_T const **sfcnUPtrs = (real32_T const **)
37045 malloc(1 * sizeof(real32_T *));
37046 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37047 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
37048 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
37049 _ssSetInputPortNumDimensions(childS, 1, 1);
37050 ssSetInputPortWidth(childS, 1, 1);
37051 }
37052 }
37053
37054 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
37055 RegNumOutputPorts);
37056 ssSetRegNumOutputPortsFcnArg(childS,childS);
37057
37058 /* outputs */
37059 {
37060 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
37061 calloc(1, sizeof(struct _ssPortOutputs));
37062 ss_VALIDATE_MEMORY(rts,outputPortInfo);
37063 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
37064 _ssSetNumOutputPorts(childS, 1);
37065
37066 /* port 0 */
37067 {
37068 _ssSetOutputPortNumDimensions(childS, 0, 1);
37069 ssSetOutputPortWidth(childS, 0, 1);
37070 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
37071 ssGetLocalBlockIO(rts))->MinMax));
37072 }
37073 }
37074
37075 /* path info */
37076 _ssSetModelName(childS, "Gain_sf");
37077 _ssSetPath(childS,
37078 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain/Generated S-Function");
37079 if (ssGetRTModel(rts) == (NULL)) {
37080 _ssSetParentSS(childS, rts);
37081 _ssSetRootSS(childS, ssGetRootSS(rts));
37082 } else {
37083 ssSetRTModel(childS,ssGetRTModel(rts));
37084 _ssSetParentSS(childS, (NULL));
37085 _ssSetRootSS(childS, childS);
37086 }
37087
37088 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
37089 (childS)->regDataType.arg1 = ((void *)(childS));
37090 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
37091 FcnSetErrorStatus);
37092 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
37093 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
37094 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
37095 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
37096
37097 /* registration */
37098#if defined(MATLAB_MEX_FILE)
37099
37100 {
37101 int_T i;
37102 mxArray *plhs[1];
37103 mxArray *prhs[4];
37104 double *pr;
37105 volatile int_T *intS = (int_T *)&childS;
37106 int_T addrlen = sizeof(SimStruct *);
37107 int_T m = addrlen/sizeof(int_T) + 1;
37108 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
37109 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
37110 pr = mxGetPr(prhs[1]);
37111 for (i = 0; i < m - 1; i++) {
37112 pr[i] = (double)intS[i];
37113 }
37114
37115 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
37116 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
37117 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
37118
37119 /* Reset port dimensions info functions because the S-function
37120 * and accelerator mex-files explicitly set their dimensions,
37121 * i.e., they are not dynamically sized. For this case, the
37122 * mex-file is responsible for the dimensions info memory
37123 * and Simulink should not free it. This is achieved by
37124 * setting the following two methods to NULL.
37125 */
37126 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
37127 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
37128
37129 /*
37130 * Setup function pointers and call mdlInitializeSizes via
37131 * simulink.c
37132 */
37133 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
37134 mxDestroyArray(plhs[0]);
37135 mxDestroyArray(prhs[0]);
37136 mxDestroyArray(prhs[1]);
37137 mxDestroyArray(prhs[2]);
37138 mxDestroyArray(prhs[3]);
37139 }
37140
37141#else
37142
37143 {
37144 Gain_sf(childS);
37145 sfcnInitializeSizes(childS);
37146 }
37147
37148#endif
37149
37150 sfcnInitializeSampleTimes(childS);
37151
37152 /* adjust sample time */
37153 ssSetSampleTime(childS, 0, 0.0);
37154 ssSetOffsetTime(childS, 0, 0.0);
37155 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
37156
37157 /* set compiled values of dynamic vector attributes */
37158 ssSetNumNonsampledZCs(childS, 0);
37159
37160 /* Update connectivity flags for each port */
37161 _ssSetInputPortConnected(childS, 0, 1);
37162 _ssSetInputPortConnected(childS, 1, 1);
37163 _ssSetOutputPortConnected(childS, 0, 1);
37164 _ssSetOutputPortBeingMerged(childS, 0, 0);
37165
37166 /* Update the BufferDstPort flags for each input port */
37167 _ssSetInputPortBufferDstPort(childS, 0, -1);
37168 _ssSetInputPortBufferDstPort(childS, 1, -1);
37169 }
37170
37171 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S260>/Generated S-Function (Gain_sf) */
37172 {
37173 SimStruct *childS = ssGetSFunction(rts, 140);
37174
37175 /* timing info */
37176 time_T *sfcnPeriod;
37177 time_T *sfcnOffset;
37178 int_T *sfcnTsMap;
37179 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
37180 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
37181 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
37182 ss_VALIDATE_MEMORY(rts,sfcnOffset);
37183 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
37184 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
37185 (void) memset((void*)sfcnPeriod, 0,
37186 sizeof(time_T)*1);
37187 (void) memset((void*)sfcnOffset, 0,
37188 sizeof(time_T)*1);
37189 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
37190 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
37191 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
37192
37193 /* Set up the mdlInfo pointer */
37194# ifdef USE_RTMODEL
37195
37196 {
37197 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
37198 struct _ssBlkInfo2));
37199 ss_VALIDATE_MEMORY(rts,blkInfo2);
37200 ssSetBlkInfo2Ptr(childS, blkInfo2);
37201 }
37202
37203 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
37204
37205# else
37206
37207 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
37208
37209# endif /* USE_RTMODEL */
37210
37211 /* Allocate memory of model methods 2 */
37212 {
37213 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
37214 malloc(sizeof(struct _ssSFcnModelMethods2));
37215 ss_VALIDATE_MEMORY(rts,methods2);
37216 ssSetModelMethods2(childS, methods2);
37217 }
37218
37219 /* Allocate memory of model methods 3 */
37220 {
37221 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
37222 malloc(sizeof(struct _ssSFcnModelMethods3));
37223 ss_VALIDATE_MEMORY(rts,methods3);
37224 ssSetModelMethods3(childS, methods3);
37225 }
37226
37227 /* Allocate memory for states auxilliary information */
37228 {
37229 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
37230 (sizeof(struct _ssStatesInfo2));
37231 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
37232 malloc(sizeof(ssPeriodicStatesInfo));
37233 ss_VALIDATE_MEMORY(rts,statesInfo2);
37234 ssSetStatesInfo2(childS, statesInfo2);
37235 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
37236 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
37237 }
37238
37239 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
37240 RegNumInputPorts);
37241 ssSetRegNumInputPortsFcnArg(childS,childS);
37242
37243 /* inputs */
37244 {
37245 struct _ssPortInputs *inputPortInfo =
37246 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
37247 ss_VALIDATE_MEMORY(rts,inputPortInfo);
37248 _ssSetNumInputPorts(childS, 2);
37249 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
37250
37251 /* port 0 */
37252 {
37253 real32_T const **sfcnUPtrs = (real32_T const **)
37254 malloc(1 * sizeof(real32_T *));
37255 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37256 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
37257 ssGetLocalBlockIO(rts))->GeneratedSFunction4_ms;
37258 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
37259 _ssSetInputPortNumDimensions(childS, 0, 1);
37260 ssSetInputPortWidth(childS, 0, 1);
37261 }
37262
37263 /* port 1 */
37264 {
37265 real32_T const **sfcnUPtrs = (real32_T const **)
37266 malloc(1 * sizeof(real32_T *));
37267 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37268 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled123;
37269 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
37270 _ssSetInputPortNumDimensions(childS, 1, 1);
37271 ssSetInputPortWidth(childS, 1, 1);
37272 }
37273 }
37274
37275 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
37276 RegNumOutputPorts);
37277 ssSetRegNumOutputPortsFcnArg(childS,childS);
37278
37279 /* outputs */
37280 {
37281 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
37282 calloc(1, sizeof(struct _ssPortOutputs));
37283 ss_VALIDATE_MEMORY(rts,outputPortInfo);
37284 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
37285 _ssSetNumOutputPorts(childS, 1);
37286
37287 /* port 0 */
37288 {
37289 _ssSetOutputPortNumDimensions(childS, 0, 1);
37290 ssSetOutputPortWidth(childS, 0, 1);
37291 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
37292 ssGetLocalBlockIO(rts))->Saturation7));
37293 }
37294 }
37295
37296 /* path info */
37297 _ssSetModelName(childS, "Gain_sf");
37298 _ssSetPath(childS,
37299 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain1/Generated S-Function");
37300 if (ssGetRTModel(rts) == (NULL)) {
37301 _ssSetParentSS(childS, rts);
37302 _ssSetRootSS(childS, ssGetRootSS(rts));
37303 } else {
37304 ssSetRTModel(childS,ssGetRTModel(rts));
37305 _ssSetParentSS(childS, (NULL));
37306 _ssSetRootSS(childS, childS);
37307 }
37308
37309 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
37310 (childS)->regDataType.arg1 = ((void *)(childS));
37311 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
37312 FcnSetErrorStatus);
37313 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
37314 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
37315 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
37316 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
37317
37318 /* registration */
37319#if defined(MATLAB_MEX_FILE)
37320
37321 {
37322 int_T i;
37323 mxArray *plhs[1];
37324 mxArray *prhs[4];
37325 double *pr;
37326 volatile int_T *intS = (int_T *)&childS;
37327 int_T addrlen = sizeof(SimStruct *);
37328 int_T m = addrlen/sizeof(int_T) + 1;
37329 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
37330 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
37331 pr = mxGetPr(prhs[1]);
37332 for (i = 0; i < m - 1; i++) {
37333 pr[i] = (double)intS[i];
37334 }
37335
37336 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
37337 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
37338 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
37339
37340 /* Reset port dimensions info functions because the S-function
37341 * and accelerator mex-files explicitly set their dimensions,
37342 * i.e., they are not dynamically sized. For this case, the
37343 * mex-file is responsible for the dimensions info memory
37344 * and Simulink should not free it. This is achieved by
37345 * setting the following two methods to NULL.
37346 */
37347 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
37348 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
37349
37350 /*
37351 * Setup function pointers and call mdlInitializeSizes via
37352 * simulink.c
37353 */
37354 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
37355 mxDestroyArray(plhs[0]);
37356 mxDestroyArray(prhs[0]);
37357 mxDestroyArray(prhs[1]);
37358 mxDestroyArray(prhs[2]);
37359 mxDestroyArray(prhs[3]);
37360 }
37361
37362#else
37363
37364 {
37365 Gain_sf(childS);
37366 sfcnInitializeSizes(childS);
37367 }
37368
37369#endif
37370
37371 sfcnInitializeSampleTimes(childS);
37372
37373 /* adjust sample time */
37374 ssSetSampleTime(childS, 0, 0.0);
37375 ssSetOffsetTime(childS, 0, 0.0);
37376 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
37377
37378 /* set compiled values of dynamic vector attributes */
37379 ssSetNumNonsampledZCs(childS, 0);
37380
37381 /* Update connectivity flags for each port */
37382 _ssSetInputPortConnected(childS, 0, 1);
37383 _ssSetInputPortConnected(childS, 1, 1);
37384 _ssSetOutputPortConnected(childS, 0, 1);
37385 _ssSetOutputPortBeingMerged(childS, 0, 0);
37386
37387 /* Update the BufferDstPort flags for each input port */
37388 _ssSetInputPortBufferDstPort(childS, 0, -1);
37389 _ssSetInputPortBufferDstPort(childS, 1, -1);
37390 }
37391
37392 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S255>/Generated S-Function9 (NegativePass_sf) */
37393 {
37394 SimStruct *childS = ssGetSFunction(rts, 141);
37395
37396 /* timing info */
37397 time_T *sfcnPeriod;
37398 time_T *sfcnOffset;
37399 int_T *sfcnTsMap;
37400 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
37401 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
37402 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
37403 ss_VALIDATE_MEMORY(rts,sfcnOffset);
37404 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
37405 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
37406 (void) memset((void*)sfcnPeriod, 0,
37407 sizeof(time_T)*1);
37408 (void) memset((void*)sfcnOffset, 0,
37409 sizeof(time_T)*1);
37410 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
37411 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
37412 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
37413
37414 /* Set up the mdlInfo pointer */
37415# ifdef USE_RTMODEL
37416
37417 {
37418 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
37419 struct _ssBlkInfo2));
37420 ss_VALIDATE_MEMORY(rts,blkInfo2);
37421 ssSetBlkInfo2Ptr(childS, blkInfo2);
37422 }
37423
37424 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
37425
37426# else
37427
37428 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
37429
37430# endif /* USE_RTMODEL */
37431
37432 /* Allocate memory of model methods 2 */
37433 {
37434 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
37435 malloc(sizeof(struct _ssSFcnModelMethods2));
37436 ss_VALIDATE_MEMORY(rts,methods2);
37437 ssSetModelMethods2(childS, methods2);
37438 }
37439
37440 /* Allocate memory of model methods 3 */
37441 {
37442 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
37443 malloc(sizeof(struct _ssSFcnModelMethods3));
37444 ss_VALIDATE_MEMORY(rts,methods3);
37445 ssSetModelMethods3(childS, methods3);
37446 }
37447
37448 /* Allocate memory for states auxilliary information */
37449 {
37450 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
37451 (sizeof(struct _ssStatesInfo2));
37452 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
37453 malloc(sizeof(ssPeriodicStatesInfo));
37454 ss_VALIDATE_MEMORY(rts,statesInfo2);
37455 ssSetStatesInfo2(childS, statesInfo2);
37456 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
37457 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
37458 }
37459
37460 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
37461 RegNumInputPorts);
37462 ssSetRegNumInputPortsFcnArg(childS,childS);
37463
37464 /* inputs */
37465 {
37466 struct _ssPortInputs *inputPortInfo =
37467 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
37468 ss_VALIDATE_MEMORY(rts,inputPortInfo);
37469 _ssSetNumInputPorts(childS, 1);
37470 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
37471
37472 /* port 0 */
37473 {
37474 real32_T const **sfcnUPtrs = (real32_T const **)
37475 malloc(1 * sizeof(real32_T *));
37476 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37477 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
37478 ssGetLocalBlockIO(rts))->Sum2_hd;
37479 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
37480 _ssSetInputPortNumDimensions(childS, 0, 1);
37481 ssSetInputPortWidth(childS, 0, 1);
37482 }
37483 }
37484
37485 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
37486 RegNumOutputPorts);
37487 ssSetRegNumOutputPortsFcnArg(childS,childS);
37488
37489 /* outputs */
37490 {
37491 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
37492 calloc(1, sizeof(struct _ssPortOutputs));
37493 ss_VALIDATE_MEMORY(rts,outputPortInfo);
37494 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
37495 _ssSetNumOutputPorts(childS, 1);
37496
37497 /* port 0 */
37498 {
37499 _ssSetOutputPortNumDimensions(childS, 0, 1);
37500 ssSetOutputPortWidth(childS, 0, 1);
37501 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
37502 ssGetLocalBlockIO(rts))->Saturation7));
37503 }
37504 }
37505
37506 /* path info */
37507 _ssSetModelName(childS, "NegativePass_sf");
37508 _ssSetPath(childS,
37509 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/ negative pass1/Generated S-Function9");
37510 if (ssGetRTModel(rts) == (NULL)) {
37511 _ssSetParentSS(childS, rts);
37512 _ssSetRootSS(childS, ssGetRootSS(rts));
37513 } else {
37514 ssSetRTModel(childS,ssGetRTModel(rts));
37515 _ssSetParentSS(childS, (NULL));
37516 _ssSetRootSS(childS, childS);
37517 }
37518
37519 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
37520 (childS)->regDataType.arg1 = ((void *)(childS));
37521 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
37522 FcnSetErrorStatus);
37523 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
37524 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
37525 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
37526 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
37527
37528 /* registration */
37529#if defined(MATLAB_MEX_FILE)
37530
37531 {
37532 int_T i;
37533 mxArray *plhs[1];
37534 mxArray *prhs[4];
37535 double *pr;
37536 volatile int_T *intS = (int_T *)&childS;
37537 int_T addrlen = sizeof(SimStruct *);
37538 int_T m = addrlen/sizeof(int_T) + 1;
37539 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
37540 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
37541 pr = mxGetPr(prhs[1]);
37542 for (i = 0; i < m - 1; i++) {
37543 pr[i] = (double)intS[i];
37544 }
37545
37546 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
37547 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
37548 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
37549
37550 /* Reset port dimensions info functions because the S-function
37551 * and accelerator mex-files explicitly set their dimensions,
37552 * i.e., they are not dynamically sized. For this case, the
37553 * mex-file is responsible for the dimensions info memory
37554 * and Simulink should not free it. This is achieved by
37555 * setting the following two methods to NULL.
37556 */
37557 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
37558 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
37559
37560 /*
37561 * Setup function pointers and call mdlInitializeSizes via
37562 * simulink.c
37563 */
37564 mexCallMATLAB(1, plhs, 4, prhs, "NegativePass_sf");
37565 mxDestroyArray(plhs[0]);
37566 mxDestroyArray(prhs[0]);
37567 mxDestroyArray(prhs[1]);
37568 mxDestroyArray(prhs[2]);
37569 mxDestroyArray(prhs[3]);
37570 }
37571
37572#else
37573
37574 {
37575 NegativePass_sf(childS);
37576 sfcnInitializeSizes(childS);
37577 }
37578
37579#endif
37580
37581 sfcnInitializeSampleTimes(childS);
37582
37583 /* adjust sample time */
37584 ssSetSampleTime(childS, 0, 0.0);
37585 ssSetOffsetTime(childS, 0, 0.0);
37586 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
37587
37588 /* set compiled values of dynamic vector attributes */
37589 ssSetNumNonsampledZCs(childS, 0);
37590
37591 /* Update connectivity flags for each port */
37592 _ssSetInputPortConnected(childS, 0, 1);
37593 _ssSetOutputPortConnected(childS, 0, 1);
37594 _ssSetOutputPortBeingMerged(childS, 0, 0);
37595
37596 /* Update the BufferDstPort flags for each input port */
37597 _ssSetInputPortBufferDstPort(childS, 0, -1);
37598 }
37599
37600 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S266>/Generated S-Function (WashoutFilter_sf) */
37601 {
37602 SimStruct *childS = ssGetSFunction(rts, 142);
37603
37604 /* timing info */
37605 time_T *sfcnPeriod;
37606 time_T *sfcnOffset;
37607 int_T *sfcnTsMap;
37608 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
37609 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
37610 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
37611 ss_VALIDATE_MEMORY(rts,sfcnOffset);
37612 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
37613 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
37614 (void) memset((void*)sfcnPeriod, 0,
37615 sizeof(time_T)*1);
37616 (void) memset((void*)sfcnOffset, 0,
37617 sizeof(time_T)*1);
37618 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
37619 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
37620 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
37621
37622 /* Set up the mdlInfo pointer */
37623# ifdef USE_RTMODEL
37624
37625 {
37626 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
37627 struct _ssBlkInfo2));
37628 ss_VALIDATE_MEMORY(rts,blkInfo2);
37629 ssSetBlkInfo2Ptr(childS, blkInfo2);
37630 }
37631
37632 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
37633
37634# else
37635
37636 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
37637
37638# endif /* USE_RTMODEL */
37639
37640 /* Allocate memory of model methods 2 */
37641 {
37642 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
37643 malloc(sizeof(struct _ssSFcnModelMethods2));
37644 ss_VALIDATE_MEMORY(rts,methods2);
37645 ssSetModelMethods2(childS, methods2);
37646 }
37647
37648 /* Allocate memory of model methods 3 */
37649 {
37650 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
37651 malloc(sizeof(struct _ssSFcnModelMethods3));
37652 ss_VALIDATE_MEMORY(rts,methods3);
37653 ssSetModelMethods3(childS, methods3);
37654 }
37655
37656 /* Allocate memory for states auxilliary information */
37657 {
37658 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
37659 (sizeof(struct _ssStatesInfo2));
37660 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
37661 malloc(sizeof(ssPeriodicStatesInfo));
37662 ss_VALIDATE_MEMORY(rts,statesInfo2);
37663 ssSetStatesInfo2(childS, statesInfo2);
37664 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
37665 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
37666 }
37667
37668 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
37669 RegNumInputPorts);
37670 ssSetRegNumInputPortsFcnArg(childS,childS);
37671
37672 /* inputs */
37673 {
37674 struct _ssPortInputs *inputPortInfo =
37675 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
37676 ss_VALIDATE_MEMORY(rts,inputPortInfo);
37677 _ssSetNumInputPorts(childS, 6);
37678 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
37679
37680 /* port 0 */
37681 {
37682 real32_T const **sfcnUPtrs = (real32_T const **)
37683 malloc(1 * sizeof(real32_T *));
37684 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37685 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
37686 ssGetLocalBlockIO(rts))->dtCAS;
37687 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
37688 _ssSetInputPortNumDimensions(childS, 0, 1);
37689 ssSetInputPortWidth(childS, 0, 1);
37690 }
37691
37692 /* port 1 */
37693 {
37694 int8_T const **sfcnUPtrs = (int8_T const **)
37695 malloc(1 * sizeof(int8_T *));
37696 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37697 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
37698 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
37699 _ssSetInputPortNumDimensions(childS, 1, 1);
37700 ssSetInputPortWidth(childS, 1, 1);
37701 }
37702
37703 /* port 2 */
37704 {
37705 real32_T const **sfcnUPtrs = (real32_T const **)
37706 malloc(1 * sizeof(real32_T *));
37707 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37708 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
37709 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
37710 _ssSetInputPortNumDimensions(childS, 2, 1);
37711 ssSetInputPortWidth(childS, 2, 1);
37712 }
37713
37714 /* port 3 */
37715 {
37716 real32_T const **sfcnUPtrs = (real32_T const **)
37717 malloc(1 * sizeof(real32_T *));
37718 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37719 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
37720 ssGetLocalBlockIO(rts))->Alfa_j;
37721 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
37722 _ssSetInputPortNumDimensions(childS, 3, 1);
37723 ssSetInputPortWidth(childS, 3, 1);
37724 }
37725
37726 /* port 4 */
37727 {
37728 real32_T const **sfcnUPtrs = (real32_T const **)
37729 malloc(1 * sizeof(real32_T *));
37730 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37731 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
37732 ssGetLocalBlockIO(rts))->Alfa_j;
37733 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
37734 _ssSetInputPortNumDimensions(childS, 4, 1);
37735 ssSetInputPortWidth(childS, 4, 1);
37736 }
37737
37738 /* port 5 */
37739 {
37740 real32_T const **sfcnUPtrs = (real32_T const **)
37741 malloc(1 * sizeof(real32_T *));
37742 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
37743 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
37744 ssGetLocalBlockIO(rts))->Alfa_j;
37745 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
37746 _ssSetInputPortNumDimensions(childS, 5, 1);
37747 ssSetInputPortWidth(childS, 5, 1);
37748 }
37749 }
37750
37751 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
37752 RegNumOutputPorts);
37753 ssSetRegNumOutputPortsFcnArg(childS,childS);
37754
37755 /* outputs */
37756 {
37757 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
37758 calloc(1, sizeof(struct _ssPortOutputs));
37759 ss_VALIDATE_MEMORY(rts,outputPortInfo);
37760 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
37761 _ssSetNumOutputPorts(childS, 1);
37762
37763 /* port 0 */
37764 {
37765 _ssSetOutputPortNumDimensions(childS, 0, 1);
37766 ssSetOutputPortWidth(childS, 0, 1);
37767 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
37768 ssGetLocalBlockIO(rts))->GeneratedSFunction_f5));
37769 }
37770 }
37771
37772 /* path info */
37773 _ssSetModelName(childS, "WashoutFilter_sf");
37774 _ssSetPath(childS,
37775 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim / high pass filter2/Generated S-Function");
37776 if (ssGetRTModel(rts) == (NULL)) {
37777 _ssSetParentSS(childS, rts);
37778 _ssSetRootSS(childS, ssGetRootSS(rts));
37779 } else {
37780 ssSetRTModel(childS,ssGetRTModel(rts));
37781 _ssSetParentSS(childS, (NULL));
37782 _ssSetRootSS(childS, childS);
37783 }
37784
37785 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
37786
37787 /* work vectors */
37788 {
37789 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
37790 (4 * sizeof(struct _ssDWorkRecord));
37791 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
37792 calloc(4, sizeof(struct _ssDWorkAuxRecord));
37793 ss_VALIDATE_MEMORY(rts,dWorkRecord);
37794 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
37795 ssSetSFcnDWork(childS, dWorkRecord);
37796 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
37797 _ssSetNumDWork(childS, 4);
37798
37799 /* DWORK0 */
37800 ssSetDWorkWidth(childS, 0, 1);
37801 ssSetDWorkDataType(childS, 0,SS_SINGLE);
37802 ssSetDWorkComplexSignal(childS, 0, 0);
37803 ssSetDWorkUsedAsDState(childS, 0, 1);
37804 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 257))[0]);
37805
37806 /* DWORK1 */
37807 ssSetDWorkWidth(childS, 1, 1);
37808 ssSetDWorkDataType(childS, 1,SS_SINGLE);
37809 ssSetDWorkComplexSignal(childS, 1, 0);
37810 ssSetDWorkUsedAsDState(childS, 1, 1);
37811 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 258))[0]);
37812
37813 /* DWORK2 */
37814 ssSetDWorkWidth(childS, 2, 1);
37815 ssSetDWorkDataType(childS, 2,SS_INT8);
37816 ssSetDWorkComplexSignal(childS, 2, 0);
37817 ssSetDWorkUsedAsDState(childS, 2, 1);
37818 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 487))[0]);
37819
37820 /* DWORK3 */
37821 ssSetDWorkWidth(childS, 3, 1);
37822 ssSetDWorkDataType(childS, 3,SS_INT8);
37823 ssSetDWorkComplexSignal(childS, 3, 0);
37824 ssSetDWorkUsedAsDState(childS, 3, 1);
37825 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 488))[0]);
37826 }
37827
37828 (childS)->regDataType.arg1 = ((void *)(childS));
37829 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
37830 FcnSetErrorStatus);
37831 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
37832 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
37833 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
37834 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
37835
37836 /* registration */
37837#if defined(MATLAB_MEX_FILE)
37838
37839 {
37840 int_T i;
37841 mxArray *plhs[1];
37842 mxArray *prhs[4];
37843 double *pr;
37844 volatile int_T *intS = (int_T *)&childS;
37845 int_T addrlen = sizeof(SimStruct *);
37846 int_T m = addrlen/sizeof(int_T) + 1;
37847 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
37848 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
37849 pr = mxGetPr(prhs[1]);
37850 for (i = 0; i < m - 1; i++) {
37851 pr[i] = (double)intS[i];
37852 }
37853
37854 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
37855 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
37856 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
37857
37858 /* Reset port dimensions info functions because the S-function
37859 * and accelerator mex-files explicitly set their dimensions,
37860 * i.e., they are not dynamically sized. For this case, the
37861 * mex-file is responsible for the dimensions info memory
37862 * and Simulink should not free it. This is achieved by
37863 * setting the following two methods to NULL.
37864 */
37865 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
37866 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
37867
37868 /*
37869 * Setup function pointers and call mdlInitializeSizes via
37870 * simulink.c
37871 */
37872 mexCallMATLAB(1, plhs, 4, prhs, "WashoutFilter_sf");
37873 mxDestroyArray(plhs[0]);
37874 mxDestroyArray(prhs[0]);
37875 mxDestroyArray(prhs[1]);
37876 mxDestroyArray(prhs[2]);
37877 mxDestroyArray(prhs[3]);
37878 }
37879
37880#else
37881
37882 {
37883 WashoutFilter_sf(childS);
37884 sfcnInitializeSizes(childS);
37885 }
37886
37887#endif
37888
37889 sfcnInitializeSampleTimes(childS);
37890
37891 /* adjust sample time */
37892 ssSetSampleTime(childS, 0, 0.0);
37893 ssSetOffsetTime(childS, 0, 0.0);
37894 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
37895
37896 /* set compiled values of dynamic vector attributes */
37897 ssSetNumNonsampledZCs(childS, 0);
37898
37899 /* Update connectivity flags for each port */
37900 _ssSetInputPortConnected(childS, 0, 1);
37901 _ssSetInputPortConnected(childS, 1, 1);
37902 _ssSetInputPortConnected(childS, 2, 1);
37903 _ssSetInputPortConnected(childS, 3, 1);
37904 _ssSetInputPortConnected(childS, 4, 1);
37905 _ssSetInputPortConnected(childS, 5, 1);
37906 _ssSetOutputPortConnected(childS, 0, 1);
37907 _ssSetOutputPortBeingMerged(childS, 0, 0);
37908
37909 /* Update the BufferDstPort flags for each input port */
37910 _ssSetInputPortBufferDstPort(childS, 0, -1);
37911 _ssSetInputPortBufferDstPort(childS, 1, -1);
37912 _ssSetInputPortBufferDstPort(childS, 2, -1);
37913 _ssSetInputPortBufferDstPort(childS, 3, -1);
37914 _ssSetInputPortBufferDstPort(childS, 4, -1);
37915 _ssSetInputPortBufferDstPort(childS, 5, -1);
37916 }
37917
37918 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S268>/Generated S-Function (Gain_sf) */
37919 {
37920 SimStruct *childS = ssGetSFunction(rts, 143);
37921
37922 /* timing info */
37923 time_T *sfcnPeriod;
37924 time_T *sfcnOffset;
37925 int_T *sfcnTsMap;
37926 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
37927 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
37928 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
37929 ss_VALIDATE_MEMORY(rts,sfcnOffset);
37930 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
37931 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
37932 (void) memset((void*)sfcnPeriod, 0,
37933 sizeof(time_T)*1);
37934 (void) memset((void*)sfcnOffset, 0,
37935 sizeof(time_T)*1);
37936 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
37937 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
37938 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
37939
37940 /* Set up the mdlInfo pointer */
37941# ifdef USE_RTMODEL
37942
37943 {
37944 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
37945 struct _ssBlkInfo2));
37946 ss_VALIDATE_MEMORY(rts,blkInfo2);
37947 ssSetBlkInfo2Ptr(childS, blkInfo2);
37948 }
37949
37950 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
37951
37952# else
37953
37954 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
37955
37956# endif /* USE_RTMODEL */
37957
37958 /* Allocate memory of model methods 2 */
37959 {
37960 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
37961 malloc(sizeof(struct _ssSFcnModelMethods2));
37962 ss_VALIDATE_MEMORY(rts,methods2);
37963 ssSetModelMethods2(childS, methods2);
37964 }
37965
37966 /* Allocate memory of model methods 3 */
37967 {
37968 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
37969 malloc(sizeof(struct _ssSFcnModelMethods3));
37970 ss_VALIDATE_MEMORY(rts,methods3);
37971 ssSetModelMethods3(childS, methods3);
37972 }
37973
37974 /* Allocate memory for states auxilliary information */
37975 {
37976 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
37977 (sizeof(struct _ssStatesInfo2));
37978 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
37979 malloc(sizeof(ssPeriodicStatesInfo));
37980 ss_VALIDATE_MEMORY(rts,statesInfo2);
37981 ssSetStatesInfo2(childS, statesInfo2);
37982 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
37983 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
37984 }
37985
37986 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
37987 RegNumInputPorts);
37988 ssSetRegNumInputPortsFcnArg(childS,childS);
37989
37990 /* inputs */
37991 {
37992 struct _ssPortInputs *inputPortInfo =
37993 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
37994 ss_VALIDATE_MEMORY(rts,inputPortInfo);
37995 _ssSetNumInputPorts(childS, 2);
37996 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
37997
37998 /* port 0 */
37999 {
38000 real32_T const **sfcnUPtrs = (real32_T const **)
38001 malloc(1 * sizeof(real32_T *));
38002 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38003 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
38004 ssGetLocalBlockIO(rts))->GeneratedSFunction_f5;
38005 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
38006 _ssSetInputPortNumDimensions(childS, 0, 1);
38007 ssSetInputPortWidth(childS, 0, 1);
38008 }
38009
38010 /* port 1 */
38011 {
38012 real32_T const **sfcnUPtrs = (real32_T const **)
38013 malloc(1 * sizeof(real32_T *));
38014 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38015 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;
38016 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
38017 _ssSetInputPortNumDimensions(childS, 1, 1);
38018 ssSetInputPortWidth(childS, 1, 1);
38019 }
38020 }
38021
38022 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
38023 RegNumOutputPorts);
38024 ssSetRegNumOutputPortsFcnArg(childS,childS);
38025
38026 /* outputs */
38027 {
38028 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
38029 calloc(1, sizeof(struct _ssPortOutputs));
38030 ss_VALIDATE_MEMORY(rts,outputPortInfo);
38031 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
38032 _ssSetNumOutputPorts(childS, 1);
38033
38034 /* port 0 */
38035 {
38036 _ssSetOutputPortNumDimensions(childS, 0, 1);
38037 ssSetOutputPortWidth(childS, 0, 1);
38038 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
38039 ssGetLocalBlockIO(rts))->MinMax));
38040 }
38041 }
38042
38043 /* path info */
38044 _ssSetModelName(childS, "Gain_sf");
38045 _ssSetPath(childS,
38046 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /gain1/Generated S-Function");
38047 if (ssGetRTModel(rts) == (NULL)) {
38048 _ssSetParentSS(childS, rts);
38049 _ssSetRootSS(childS, ssGetRootSS(rts));
38050 } else {
38051 ssSetRTModel(childS,ssGetRTModel(rts));
38052 _ssSetParentSS(childS, (NULL));
38053 _ssSetRootSS(childS, childS);
38054 }
38055
38056 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
38057 (childS)->regDataType.arg1 = ((void *)(childS));
38058 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
38059 FcnSetErrorStatus);
38060 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
38061 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
38062 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
38063 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
38064
38065 /* registration */
38066#if defined(MATLAB_MEX_FILE)
38067
38068 {
38069 int_T i;
38070 mxArray *plhs[1];
38071 mxArray *prhs[4];
38072 double *pr;
38073 volatile int_T *intS = (int_T *)&childS;
38074 int_T addrlen = sizeof(SimStruct *);
38075 int_T m = addrlen/sizeof(int_T) + 1;
38076 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
38077 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
38078 pr = mxGetPr(prhs[1]);
38079 for (i = 0; i < m - 1; i++) {
38080 pr[i] = (double)intS[i];
38081 }
38082
38083 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
38084 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
38085 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
38086
38087 /* Reset port dimensions info functions because the S-function
38088 * and accelerator mex-files explicitly set their dimensions,
38089 * i.e., they are not dynamically sized. For this case, the
38090 * mex-file is responsible for the dimensions info memory
38091 * and Simulink should not free it. This is achieved by
38092 * setting the following two methods to NULL.
38093 */
38094 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
38095 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
38096
38097 /*
38098 * Setup function pointers and call mdlInitializeSizes via
38099 * simulink.c
38100 */
38101 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
38102 mxDestroyArray(plhs[0]);
38103 mxDestroyArray(prhs[0]);
38104 mxDestroyArray(prhs[1]);
38105 mxDestroyArray(prhs[2]);
38106 mxDestroyArray(prhs[3]);
38107 }
38108
38109#else
38110
38111 {
38112 Gain_sf(childS);
38113 sfcnInitializeSizes(childS);
38114 }
38115
38116#endif
38117
38118 sfcnInitializeSampleTimes(childS);
38119
38120 /* adjust sample time */
38121 ssSetSampleTime(childS, 0, 0.0);
38122 ssSetOffsetTime(childS, 0, 0.0);
38123 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
38124
38125 /* set compiled values of dynamic vector attributes */
38126 ssSetNumNonsampledZCs(childS, 0);
38127
38128 /* Update connectivity flags for each port */
38129 _ssSetInputPortConnected(childS, 0, 1);
38130 _ssSetInputPortConnected(childS, 1, 1);
38131 _ssSetOutputPortConnected(childS, 0, 1);
38132 _ssSetOutputPortBeingMerged(childS, 0, 0);
38133
38134 /* Update the BufferDstPort flags for each input port */
38135 _ssSetInputPortBufferDstPort(childS, 0, -1);
38136 _ssSetInputPortBufferDstPort(childS, 1, -1);
38137 }
38138
38139 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S265>/Generated S-Function8 (WashoutFilter_sf) */
38140 {
38141 SimStruct *childS = ssGetSFunction(rts, 144);
38142
38143 /* timing info */
38144 time_T *sfcnPeriod;
38145 time_T *sfcnOffset;
38146 int_T *sfcnTsMap;
38147 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
38148 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
38149 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
38150 ss_VALIDATE_MEMORY(rts,sfcnOffset);
38151 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
38152 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
38153 (void) memset((void*)sfcnPeriod, 0,
38154 sizeof(time_T)*1);
38155 (void) memset((void*)sfcnOffset, 0,
38156 sizeof(time_T)*1);
38157 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
38158 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
38159 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
38160
38161 /* Set up the mdlInfo pointer */
38162# ifdef USE_RTMODEL
38163
38164 {
38165 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
38166 struct _ssBlkInfo2));
38167 ss_VALIDATE_MEMORY(rts,blkInfo2);
38168 ssSetBlkInfo2Ptr(childS, blkInfo2);
38169 }
38170
38171 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
38172
38173# else
38174
38175 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
38176
38177# endif /* USE_RTMODEL */
38178
38179 /* Allocate memory of model methods 2 */
38180 {
38181 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
38182 malloc(sizeof(struct _ssSFcnModelMethods2));
38183 ss_VALIDATE_MEMORY(rts,methods2);
38184 ssSetModelMethods2(childS, methods2);
38185 }
38186
38187 /* Allocate memory of model methods 3 */
38188 {
38189 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
38190 malloc(sizeof(struct _ssSFcnModelMethods3));
38191 ss_VALIDATE_MEMORY(rts,methods3);
38192 ssSetModelMethods3(childS, methods3);
38193 }
38194
38195 /* Allocate memory for states auxilliary information */
38196 {
38197 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
38198 (sizeof(struct _ssStatesInfo2));
38199 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
38200 malloc(sizeof(ssPeriodicStatesInfo));
38201 ss_VALIDATE_MEMORY(rts,statesInfo2);
38202 ssSetStatesInfo2(childS, statesInfo2);
38203 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
38204 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
38205 }
38206
38207 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
38208 RegNumInputPorts);
38209 ssSetRegNumInputPortsFcnArg(childS,childS);
38210
38211 /* inputs */
38212 {
38213 struct _ssPortInputs *inputPortInfo =
38214 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
38215 ss_VALIDATE_MEMORY(rts,inputPortInfo);
38216 _ssSetNumInputPorts(childS, 6);
38217 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
38218
38219 /* port 0 */
38220 {
38221 real32_T const **sfcnUPtrs = (real32_T const **)
38222 malloc(1 * sizeof(real32_T *));
38223 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38224 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
38225 ssGetLocalBlockIO(rts))->dtCAS;
38226 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
38227 _ssSetInputPortNumDimensions(childS, 0, 1);
38228 ssSetInputPortWidth(childS, 0, 1);
38229 }
38230
38231 /* port 1 */
38232 {
38233 int8_T const **sfcnUPtrs = (int8_T const **)
38234 malloc(1 * sizeof(int8_T *));
38235 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38236 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
38237 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
38238 _ssSetInputPortNumDimensions(childS, 1, 1);
38239 ssSetInputPortWidth(childS, 1, 1);
38240 }
38241
38242 /* port 2 */
38243 {
38244 real32_T const **sfcnUPtrs = (real32_T const **)
38245 malloc(1 * sizeof(real32_T *));
38246 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38247 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;
38248 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
38249 _ssSetInputPortNumDimensions(childS, 2, 1);
38250 ssSetInputPortWidth(childS, 2, 1);
38251 }
38252
38253 /* port 3 */
38254 {
38255 real32_T const **sfcnUPtrs = (real32_T const **)
38256 malloc(1 * sizeof(real32_T *));
38257 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38258 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
38259 ssGetLocalBlockIO(rts))->q_k;
38260 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
38261 _ssSetInputPortNumDimensions(childS, 3, 1);
38262 ssSetInputPortWidth(childS, 3, 1);
38263 }
38264
38265 /* port 4 */
38266 {
38267 real32_T const **sfcnUPtrs = (real32_T const **)
38268 malloc(1 * sizeof(real32_T *));
38269 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38270 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
38271 ssGetLocalBlockIO(rts))->q_k;
38272 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
38273 _ssSetInputPortNumDimensions(childS, 4, 1);
38274 ssSetInputPortWidth(childS, 4, 1);
38275 }
38276
38277 /* port 5 */
38278 {
38279 real32_T const **sfcnUPtrs = (real32_T const **)
38280 malloc(1 * sizeof(real32_T *));
38281 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38282 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
38283 ssGetLocalBlockIO(rts))->q_k;
38284 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
38285 _ssSetInputPortNumDimensions(childS, 5, 1);
38286 ssSetInputPortWidth(childS, 5, 1);
38287 }
38288 }
38289
38290 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
38291 RegNumOutputPorts);
38292 ssSetRegNumOutputPortsFcnArg(childS,childS);
38293
38294 /* outputs */
38295 {
38296 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
38297 calloc(1, sizeof(struct _ssPortOutputs));
38298 ss_VALIDATE_MEMORY(rts,outputPortInfo);
38299 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
38300 _ssSetNumOutputPorts(childS, 1);
38301
38302 /* port 0 */
38303 {
38304 _ssSetOutputPortNumDimensions(childS, 0, 1);
38305 ssSetOutputPortWidth(childS, 0, 1);
38306 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
38307 ssGetLocalBlockIO(rts))->GeneratedSFunction8_e));
38308 }
38309 }
38310
38311 /* path info */
38312 _ssSetModelName(childS, "WashoutFilter_sf");
38313 _ssSetPath(childS,
38314 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim / high pass filter1/Generated S-Function8");
38315 if (ssGetRTModel(rts) == (NULL)) {
38316 _ssSetParentSS(childS, rts);
38317 _ssSetRootSS(childS, ssGetRootSS(rts));
38318 } else {
38319 ssSetRTModel(childS,ssGetRTModel(rts));
38320 _ssSetParentSS(childS, (NULL));
38321 _ssSetRootSS(childS, childS);
38322 }
38323
38324 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
38325
38326 /* work vectors */
38327 {
38328 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
38329 (4 * sizeof(struct _ssDWorkRecord));
38330 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
38331 calloc(4, sizeof(struct _ssDWorkAuxRecord));
38332 ss_VALIDATE_MEMORY(rts,dWorkRecord);
38333 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
38334 ssSetSFcnDWork(childS, dWorkRecord);
38335 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
38336 _ssSetNumDWork(childS, 4);
38337
38338 /* DWORK0 */
38339 ssSetDWorkWidth(childS, 0, 1);
38340 ssSetDWorkDataType(childS, 0,SS_SINGLE);
38341 ssSetDWorkComplexSignal(childS, 0, 0);
38342 ssSetDWorkUsedAsDState(childS, 0, 1);
38343 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 259))[0]);
38344
38345 /* DWORK1 */
38346 ssSetDWorkWidth(childS, 1, 1);
38347 ssSetDWorkDataType(childS, 1,SS_SINGLE);
38348 ssSetDWorkComplexSignal(childS, 1, 0);
38349 ssSetDWorkUsedAsDState(childS, 1, 1);
38350 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 260))[0]);
38351
38352 /* DWORK2 */
38353 ssSetDWorkWidth(childS, 2, 1);
38354 ssSetDWorkDataType(childS, 2,SS_INT8);
38355 ssSetDWorkComplexSignal(childS, 2, 0);
38356 ssSetDWorkUsedAsDState(childS, 2, 1);
38357 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 489))[0]);
38358
38359 /* DWORK3 */
38360 ssSetDWorkWidth(childS, 3, 1);
38361 ssSetDWorkDataType(childS, 3,SS_INT8);
38362 ssSetDWorkComplexSignal(childS, 3, 0);
38363 ssSetDWorkUsedAsDState(childS, 3, 1);
38364 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 490))[0]);
38365 }
38366
38367 (childS)->regDataType.arg1 = ((void *)(childS));
38368 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
38369 FcnSetErrorStatus);
38370 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
38371 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
38372 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
38373 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
38374
38375 /* registration */
38376#if defined(MATLAB_MEX_FILE)
38377
38378 {
38379 int_T i;
38380 mxArray *plhs[1];
38381 mxArray *prhs[4];
38382 double *pr;
38383 volatile int_T *intS = (int_T *)&childS;
38384 int_T addrlen = sizeof(SimStruct *);
38385 int_T m = addrlen/sizeof(int_T) + 1;
38386 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
38387 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
38388 pr = mxGetPr(prhs[1]);
38389 for (i = 0; i < m - 1; i++) {
38390 pr[i] = (double)intS[i];
38391 }
38392
38393 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
38394 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
38395 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
38396
38397 /* Reset port dimensions info functions because the S-function
38398 * and accelerator mex-files explicitly set their dimensions,
38399 * i.e., they are not dynamically sized. For this case, the
38400 * mex-file is responsible for the dimensions info memory
38401 * and Simulink should not free it. This is achieved by
38402 * setting the following two methods to NULL.
38403 */
38404 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
38405 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
38406
38407 /*
38408 * Setup function pointers and call mdlInitializeSizes via
38409 * simulink.c
38410 */
38411 mexCallMATLAB(1, plhs, 4, prhs, "WashoutFilter_sf");
38412 mxDestroyArray(plhs[0]);
38413 mxDestroyArray(prhs[0]);
38414 mxDestroyArray(prhs[1]);
38415 mxDestroyArray(prhs[2]);
38416 mxDestroyArray(prhs[3]);
38417 }
38418
38419#else
38420
38421 {
38422 WashoutFilter_sf(childS);
38423 sfcnInitializeSizes(childS);
38424 }
38425
38426#endif
38427
38428 sfcnInitializeSampleTimes(childS);
38429
38430 /* adjust sample time */
38431 ssSetSampleTime(childS, 0, 0.0);
38432 ssSetOffsetTime(childS, 0, 0.0);
38433 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
38434
38435 /* set compiled values of dynamic vector attributes */
38436 ssSetNumNonsampledZCs(childS, 0);
38437
38438 /* Update connectivity flags for each port */
38439 _ssSetInputPortConnected(childS, 0, 1);
38440 _ssSetInputPortConnected(childS, 1, 1);
38441 _ssSetInputPortConnected(childS, 2, 1);
38442 _ssSetInputPortConnected(childS, 3, 1);
38443 _ssSetInputPortConnected(childS, 4, 1);
38444 _ssSetInputPortConnected(childS, 5, 1);
38445 _ssSetOutputPortConnected(childS, 0, 1);
38446 _ssSetOutputPortBeingMerged(childS, 0, 0);
38447
38448 /* Update the BufferDstPort flags for each input port */
38449 _ssSetInputPortBufferDstPort(childS, 0, -1);
38450 _ssSetInputPortBufferDstPort(childS, 1, -1);
38451 _ssSetInputPortBufferDstPort(childS, 2, -1);
38452 _ssSetInputPortBufferDstPort(childS, 3, -1);
38453 _ssSetInputPortBufferDstPort(childS, 4, -1);
38454 _ssSetInputPortBufferDstPort(childS, 5, -1);
38455 }
38456
38457 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S269>/Generated S-Function (Gain_sf) */
38458 {
38459 SimStruct *childS = ssGetSFunction(rts, 145);
38460
38461 /* timing info */
38462 time_T *sfcnPeriod;
38463 time_T *sfcnOffset;
38464 int_T *sfcnTsMap;
38465 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
38466 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
38467 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
38468 ss_VALIDATE_MEMORY(rts,sfcnOffset);
38469 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
38470 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
38471 (void) memset((void*)sfcnPeriod, 0,
38472 sizeof(time_T)*1);
38473 (void) memset((void*)sfcnOffset, 0,
38474 sizeof(time_T)*1);
38475 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
38476 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
38477 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
38478
38479 /* Set up the mdlInfo pointer */
38480# ifdef USE_RTMODEL
38481
38482 {
38483 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
38484 struct _ssBlkInfo2));
38485 ss_VALIDATE_MEMORY(rts,blkInfo2);
38486 ssSetBlkInfo2Ptr(childS, blkInfo2);
38487 }
38488
38489 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
38490
38491# else
38492
38493 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
38494
38495# endif /* USE_RTMODEL */
38496
38497 /* Allocate memory of model methods 2 */
38498 {
38499 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
38500 malloc(sizeof(struct _ssSFcnModelMethods2));
38501 ss_VALIDATE_MEMORY(rts,methods2);
38502 ssSetModelMethods2(childS, methods2);
38503 }
38504
38505 /* Allocate memory of model methods 3 */
38506 {
38507 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
38508 malloc(sizeof(struct _ssSFcnModelMethods3));
38509 ss_VALIDATE_MEMORY(rts,methods3);
38510 ssSetModelMethods3(childS, methods3);
38511 }
38512
38513 /* Allocate memory for states auxilliary information */
38514 {
38515 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
38516 (sizeof(struct _ssStatesInfo2));
38517 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
38518 malloc(sizeof(ssPeriodicStatesInfo));
38519 ss_VALIDATE_MEMORY(rts,statesInfo2);
38520 ssSetStatesInfo2(childS, statesInfo2);
38521 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
38522 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
38523 }
38524
38525 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
38526 RegNumInputPorts);
38527 ssSetRegNumInputPortsFcnArg(childS,childS);
38528
38529 /* inputs */
38530 {
38531 struct _ssPortInputs *inputPortInfo =
38532 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
38533 ss_VALIDATE_MEMORY(rts,inputPortInfo);
38534 _ssSetNumInputPorts(childS, 2);
38535 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
38536
38537 /* port 0 */
38538 {
38539 real32_T const **sfcnUPtrs = (real32_T const **)
38540 malloc(1 * sizeof(real32_T *));
38541 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38542 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
38543 ssGetLocalBlockIO(rts))->GeneratedSFunction8_e;
38544 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
38545 _ssSetInputPortNumDimensions(childS, 0, 1);
38546 ssSetInputPortWidth(childS, 0, 1);
38547 }
38548
38549 /* port 1 */
38550 {
38551 real32_T const **sfcnUPtrs = (real32_T const **)
38552 malloc(1 * sizeof(real32_T *));
38553 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38554 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled133;
38555 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
38556 _ssSetInputPortNumDimensions(childS, 1, 1);
38557 ssSetInputPortWidth(childS, 1, 1);
38558 }
38559 }
38560
38561 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
38562 RegNumOutputPorts);
38563 ssSetRegNumOutputPortsFcnArg(childS,childS);
38564
38565 /* outputs */
38566 {
38567 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
38568 calloc(1, sizeof(struct _ssPortOutputs));
38569 ss_VALIDATE_MEMORY(rts,outputPortInfo);
38570 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
38571 _ssSetNumOutputPorts(childS, 1);
38572
38573 /* port 0 */
38574 {
38575 _ssSetOutputPortNumDimensions(childS, 0, 1);
38576 ssSetOutputPortWidth(childS, 0, 1);
38577 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
38578 ssGetLocalBlockIO(rts))->GeneratedSFunction7_o1));
38579 }
38580 }
38581
38582 /* path info */
38583 _ssSetModelName(childS, "Gain_sf");
38584 _ssSetPath(childS,
38585 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /gain10/Generated S-Function");
38586 if (ssGetRTModel(rts) == (NULL)) {
38587 _ssSetParentSS(childS, rts);
38588 _ssSetRootSS(childS, ssGetRootSS(rts));
38589 } else {
38590 ssSetRTModel(childS,ssGetRTModel(rts));
38591 _ssSetParentSS(childS, (NULL));
38592 _ssSetRootSS(childS, childS);
38593 }
38594
38595 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
38596 (childS)->regDataType.arg1 = ((void *)(childS));
38597 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
38598 FcnSetErrorStatus);
38599 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
38600 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
38601 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
38602 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
38603
38604 /* registration */
38605#if defined(MATLAB_MEX_FILE)
38606
38607 {
38608 int_T i;
38609 mxArray *plhs[1];
38610 mxArray *prhs[4];
38611 double *pr;
38612 volatile int_T *intS = (int_T *)&childS;
38613 int_T addrlen = sizeof(SimStruct *);
38614 int_T m = addrlen/sizeof(int_T) + 1;
38615 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
38616 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
38617 pr = mxGetPr(prhs[1]);
38618 for (i = 0; i < m - 1; i++) {
38619 pr[i] = (double)intS[i];
38620 }
38621
38622 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
38623 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
38624 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
38625
38626 /* Reset port dimensions info functions because the S-function
38627 * and accelerator mex-files explicitly set their dimensions,
38628 * i.e., they are not dynamically sized. For this case, the
38629 * mex-file is responsible for the dimensions info memory
38630 * and Simulink should not free it. This is achieved by
38631 * setting the following two methods to NULL.
38632 */
38633 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
38634 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
38635
38636 /*
38637 * Setup function pointers and call mdlInitializeSizes via
38638 * simulink.c
38639 */
38640 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
38641 mxDestroyArray(plhs[0]);
38642 mxDestroyArray(prhs[0]);
38643 mxDestroyArray(prhs[1]);
38644 mxDestroyArray(prhs[2]);
38645 mxDestroyArray(prhs[3]);
38646 }
38647
38648#else
38649
38650 {
38651 Gain_sf(childS);
38652 sfcnInitializeSizes(childS);
38653 }
38654
38655#endif
38656
38657 sfcnInitializeSampleTimes(childS);
38658
38659 /* adjust sample time */
38660 ssSetSampleTime(childS, 0, 0.0);
38661 ssSetOffsetTime(childS, 0, 0.0);
38662 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
38663
38664 /* set compiled values of dynamic vector attributes */
38665 ssSetNumNonsampledZCs(childS, 0);
38666
38667 /* Update connectivity flags for each port */
38668 _ssSetInputPortConnected(childS, 0, 1);
38669 _ssSetInputPortConnected(childS, 1, 1);
38670 _ssSetOutputPortConnected(childS, 0, 1);
38671 _ssSetOutputPortBeingMerged(childS, 0, 0);
38672
38673 /* Update the BufferDstPort flags for each input port */
38674 _ssSetInputPortBufferDstPort(childS, 0, -1);
38675 _ssSetInputPortBufferDstPort(childS, 1, -1);
38676 }
38677
38678 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S267>/Generated S-Function (NegativePass_sf) */
38679 {
38680 SimStruct *childS = ssGetSFunction(rts, 146);
38681
38682 /* timing info */
38683 time_T *sfcnPeriod;
38684 time_T *sfcnOffset;
38685 int_T *sfcnTsMap;
38686 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
38687 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
38688 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
38689 ss_VALIDATE_MEMORY(rts,sfcnOffset);
38690 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
38691 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
38692 (void) memset((void*)sfcnPeriod, 0,
38693 sizeof(time_T)*1);
38694 (void) memset((void*)sfcnOffset, 0,
38695 sizeof(time_T)*1);
38696 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
38697 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
38698 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
38699
38700 /* Set up the mdlInfo pointer */
38701# ifdef USE_RTMODEL
38702
38703 {
38704 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
38705 struct _ssBlkInfo2));
38706 ss_VALIDATE_MEMORY(rts,blkInfo2);
38707 ssSetBlkInfo2Ptr(childS, blkInfo2);
38708 }
38709
38710 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
38711
38712# else
38713
38714 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
38715
38716# endif /* USE_RTMODEL */
38717
38718 /* Allocate memory of model methods 2 */
38719 {
38720 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
38721 malloc(sizeof(struct _ssSFcnModelMethods2));
38722 ss_VALIDATE_MEMORY(rts,methods2);
38723 ssSetModelMethods2(childS, methods2);
38724 }
38725
38726 /* Allocate memory of model methods 3 */
38727 {
38728 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
38729 malloc(sizeof(struct _ssSFcnModelMethods3));
38730 ss_VALIDATE_MEMORY(rts,methods3);
38731 ssSetModelMethods3(childS, methods3);
38732 }
38733
38734 /* Allocate memory for states auxilliary information */
38735 {
38736 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
38737 (sizeof(struct _ssStatesInfo2));
38738 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
38739 malloc(sizeof(ssPeriodicStatesInfo));
38740 ss_VALIDATE_MEMORY(rts,statesInfo2);
38741 ssSetStatesInfo2(childS, statesInfo2);
38742 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
38743 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
38744 }
38745
38746 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
38747 RegNumInputPorts);
38748 ssSetRegNumInputPortsFcnArg(childS,childS);
38749
38750 /* inputs */
38751 {
38752 struct _ssPortInputs *inputPortInfo =
38753 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
38754 ss_VALIDATE_MEMORY(rts,inputPortInfo);
38755 _ssSetNumInputPorts(childS, 1);
38756 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
38757
38758 /* port 0 */
38759 {
38760 real32_T const **sfcnUPtrs = (real32_T const **)
38761 malloc(1 * sizeof(real32_T *));
38762 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38763 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
38764 ssGetLocalBlockIO(rts))->Sum12;
38765 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
38766 _ssSetInputPortNumDimensions(childS, 0, 1);
38767 ssSetInputPortWidth(childS, 0, 1);
38768 }
38769 }
38770
38771 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
38772 RegNumOutputPorts);
38773 ssSetRegNumOutputPortsFcnArg(childS,childS);
38774
38775 /* outputs */
38776 {
38777 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
38778 calloc(1, sizeof(struct _ssPortOutputs));
38779 ss_VALIDATE_MEMORY(rts,outputPortInfo);
38780 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
38781 _ssSetNumOutputPorts(childS, 1);
38782
38783 /* port 0 */
38784 {
38785 _ssSetOutputPortNumDimensions(childS, 0, 1);
38786 ssSetOutputPortWidth(childS, 0, 1);
38787 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
38788 ssGetLocalBlockIO(rts))->GeneratedSFunction_hl));
38789 }
38790 }
38791
38792 /* path info */
38793 _ssSetModelName(childS, "NegativePass_sf");
38794 _ssSetPath(childS,
38795 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim / negative pass1/Generated S-Function");
38796 if (ssGetRTModel(rts) == (NULL)) {
38797 _ssSetParentSS(childS, rts);
38798 _ssSetRootSS(childS, ssGetRootSS(rts));
38799 } else {
38800 ssSetRTModel(childS,ssGetRTModel(rts));
38801 _ssSetParentSS(childS, (NULL));
38802 _ssSetRootSS(childS, childS);
38803 }
38804
38805 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
38806 (childS)->regDataType.arg1 = ((void *)(childS));
38807 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
38808 FcnSetErrorStatus);
38809 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
38810 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
38811 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
38812 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
38813
38814 /* registration */
38815#if defined(MATLAB_MEX_FILE)
38816
38817 {
38818 int_T i;
38819 mxArray *plhs[1];
38820 mxArray *prhs[4];
38821 double *pr;
38822 volatile int_T *intS = (int_T *)&childS;
38823 int_T addrlen = sizeof(SimStruct *);
38824 int_T m = addrlen/sizeof(int_T) + 1;
38825 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
38826 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
38827 pr = mxGetPr(prhs[1]);
38828 for (i = 0; i < m - 1; i++) {
38829 pr[i] = (double)intS[i];
38830 }
38831
38832 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
38833 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
38834 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
38835
38836 /* Reset port dimensions info functions because the S-function
38837 * and accelerator mex-files explicitly set their dimensions,
38838 * i.e., they are not dynamically sized. For this case, the
38839 * mex-file is responsible for the dimensions info memory
38840 * and Simulink should not free it. This is achieved by
38841 * setting the following two methods to NULL.
38842 */
38843 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
38844 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
38845
38846 /*
38847 * Setup function pointers and call mdlInitializeSizes via
38848 * simulink.c
38849 */
38850 mexCallMATLAB(1, plhs, 4, prhs, "NegativePass_sf");
38851 mxDestroyArray(plhs[0]);
38852 mxDestroyArray(prhs[0]);
38853 mxDestroyArray(prhs[1]);
38854 mxDestroyArray(prhs[2]);
38855 mxDestroyArray(prhs[3]);
38856 }
38857
38858#else
38859
38860 {
38861 NegativePass_sf(childS);
38862 sfcnInitializeSizes(childS);
38863 }
38864
38865#endif
38866
38867 sfcnInitializeSampleTimes(childS);
38868
38869 /* adjust sample time */
38870 ssSetSampleTime(childS, 0, 0.0);
38871 ssSetOffsetTime(childS, 0, 0.0);
38872 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
38873
38874 /* set compiled values of dynamic vector attributes */
38875 ssSetNumNonsampledZCs(childS, 0);
38876
38877 /* Update connectivity flags for each port */
38878 _ssSetInputPortConnected(childS, 0, 1);
38879 _ssSetOutputPortConnected(childS, 0, 1);
38880 _ssSetOutputPortBeingMerged(childS, 0, 0);
38881
38882 /* Update the BufferDstPort flags for each input port */
38883 _ssSetInputPortBufferDstPort(childS, 0, -1);
38884 }
38885
38886 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S270>/Generated S-Function (Gain_sf) */
38887 {
38888 SimStruct *childS = ssGetSFunction(rts, 147);
38889
38890 /* timing info */
38891 time_T *sfcnPeriod;
38892 time_T *sfcnOffset;
38893 int_T *sfcnTsMap;
38894 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
38895 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
38896 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
38897 ss_VALIDATE_MEMORY(rts,sfcnOffset);
38898 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
38899 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
38900 (void) memset((void*)sfcnPeriod, 0,
38901 sizeof(time_T)*1);
38902 (void) memset((void*)sfcnOffset, 0,
38903 sizeof(time_T)*1);
38904 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
38905 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
38906 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
38907
38908 /* Set up the mdlInfo pointer */
38909# ifdef USE_RTMODEL
38910
38911 {
38912 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
38913 struct _ssBlkInfo2));
38914 ss_VALIDATE_MEMORY(rts,blkInfo2);
38915 ssSetBlkInfo2Ptr(childS, blkInfo2);
38916 }
38917
38918 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
38919
38920# else
38921
38922 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
38923
38924# endif /* USE_RTMODEL */
38925
38926 /* Allocate memory of model methods 2 */
38927 {
38928 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
38929 malloc(sizeof(struct _ssSFcnModelMethods2));
38930 ss_VALIDATE_MEMORY(rts,methods2);
38931 ssSetModelMethods2(childS, methods2);
38932 }
38933
38934 /* Allocate memory of model methods 3 */
38935 {
38936 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
38937 malloc(sizeof(struct _ssSFcnModelMethods3));
38938 ss_VALIDATE_MEMORY(rts,methods3);
38939 ssSetModelMethods3(childS, methods3);
38940 }
38941
38942 /* Allocate memory for states auxilliary information */
38943 {
38944 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
38945 (sizeof(struct _ssStatesInfo2));
38946 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
38947 malloc(sizeof(ssPeriodicStatesInfo));
38948 ss_VALIDATE_MEMORY(rts,statesInfo2);
38949 ssSetStatesInfo2(childS, statesInfo2);
38950 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
38951 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
38952 }
38953
38954 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
38955 RegNumInputPorts);
38956 ssSetRegNumInputPortsFcnArg(childS,childS);
38957
38958 /* inputs */
38959 {
38960 struct _ssPortInputs *inputPortInfo =
38961 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
38962 ss_VALIDATE_MEMORY(rts,inputPortInfo);
38963 _ssSetNumInputPorts(childS, 2);
38964 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
38965
38966 /* port 0 */
38967 {
38968 real32_T const **sfcnUPtrs = (real32_T const **)
38969 malloc(1 * sizeof(real32_T *));
38970 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38971 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
38972 ssGetLocalBlockIO(rts))->GeneratedSFunction_hl;
38973 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
38974 _ssSetInputPortNumDimensions(childS, 0, 1);
38975 ssSetInputPortWidth(childS, 0, 1);
38976 }
38977
38978 /* port 1 */
38979 {
38980 real32_T const **sfcnUPtrs = (real32_T const **)
38981 malloc(1 * sizeof(real32_T *));
38982 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
38983 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;
38984 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
38985 _ssSetInputPortNumDimensions(childS, 1, 1);
38986 ssSetInputPortWidth(childS, 1, 1);
38987 }
38988 }
38989
38990 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
38991 RegNumOutputPorts);
38992 ssSetRegNumOutputPortsFcnArg(childS,childS);
38993
38994 /* outputs */
38995 {
38996 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
38997 calloc(1, sizeof(struct _ssPortOutputs));
38998 ss_VALIDATE_MEMORY(rts,outputPortInfo);
38999 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
39000 _ssSetNumOutputPorts(childS, 1);
39001
39002 /* port 0 */
39003 {
39004 _ssSetOutputPortNumDimensions(childS, 0, 1);
39005 ssSetOutputPortWidth(childS, 0, 1);
39006 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
39007 ssGetLocalBlockIO(rts))->GeneratedSFunction7_o1));
39008 }
39009 }
39010
39011 /* path info */
39012 _ssSetModelName(childS, "Gain_sf");
39013 _ssSetPath(childS,
39014 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /gain11/Generated S-Function");
39015 if (ssGetRTModel(rts) == (NULL)) {
39016 _ssSetParentSS(childS, rts);
39017 _ssSetRootSS(childS, ssGetRootSS(rts));
39018 } else {
39019 ssSetRTModel(childS,ssGetRTModel(rts));
39020 _ssSetParentSS(childS, (NULL));
39021 _ssSetRootSS(childS, childS);
39022 }
39023
39024 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
39025 (childS)->regDataType.arg1 = ((void *)(childS));
39026 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
39027 FcnSetErrorStatus);
39028 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
39029 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
39030 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
39031 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
39032
39033 /* registration */
39034#if defined(MATLAB_MEX_FILE)
39035
39036 {
39037 int_T i;
39038 mxArray *plhs[1];
39039 mxArray *prhs[4];
39040 double *pr;
39041 volatile int_T *intS = (int_T *)&childS;
39042 int_T addrlen = sizeof(SimStruct *);
39043 int_T m = addrlen/sizeof(int_T) + 1;
39044 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
39045 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
39046 pr = mxGetPr(prhs[1]);
39047 for (i = 0; i < m - 1; i++) {
39048 pr[i] = (double)intS[i];
39049 }
39050
39051 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
39052 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
39053 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
39054
39055 /* Reset port dimensions info functions because the S-function
39056 * and accelerator mex-files explicitly set their dimensions,
39057 * i.e., they are not dynamically sized. For this case, the
39058 * mex-file is responsible for the dimensions info memory
39059 * and Simulink should not free it. This is achieved by
39060 * setting the following two methods to NULL.
39061 */
39062 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
39063 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
39064
39065 /*
39066 * Setup function pointers and call mdlInitializeSizes via
39067 * simulink.c
39068 */
39069 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
39070 mxDestroyArray(plhs[0]);
39071 mxDestroyArray(prhs[0]);
39072 mxDestroyArray(prhs[1]);
39073 mxDestroyArray(prhs[2]);
39074 mxDestroyArray(prhs[3]);
39075 }
39076
39077#else
39078
39079 {
39080 Gain_sf(childS);
39081 sfcnInitializeSizes(childS);
39082 }
39083
39084#endif
39085
39086 sfcnInitializeSampleTimes(childS);
39087
39088 /* adjust sample time */
39089 ssSetSampleTime(childS, 0, 0.0);
39090 ssSetOffsetTime(childS, 0, 0.0);
39091 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
39092
39093 /* set compiled values of dynamic vector attributes */
39094 ssSetNumNonsampledZCs(childS, 0);
39095
39096 /* Update connectivity flags for each port */
39097 _ssSetInputPortConnected(childS, 0, 1);
39098 _ssSetInputPortConnected(childS, 1, 1);
39099 _ssSetOutputPortConnected(childS, 0, 1);
39100 _ssSetOutputPortBeingMerged(childS, 0, 0);
39101
39102 /* Update the BufferDstPort flags for each input port */
39103 _ssSetInputPortBufferDstPort(childS, 0, -1);
39104 _ssSetInputPortBufferDstPort(childS, 1, -1);
39105 }
39106
39107 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S272>/Generated S-Function (PositivePass_sf) */
39108 {
39109 SimStruct *childS = ssGetSFunction(rts, 148);
39110
39111 /* timing info */
39112 time_T *sfcnPeriod;
39113 time_T *sfcnOffset;
39114 int_T *sfcnTsMap;
39115 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
39116 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
39117 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
39118 ss_VALIDATE_MEMORY(rts,sfcnOffset);
39119 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
39120 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
39121 (void) memset((void*)sfcnPeriod, 0,
39122 sizeof(time_T)*1);
39123 (void) memset((void*)sfcnOffset, 0,
39124 sizeof(time_T)*1);
39125 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
39126 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
39127 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
39128
39129 /* Set up the mdlInfo pointer */
39130# ifdef USE_RTMODEL
39131
39132 {
39133 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
39134 struct _ssBlkInfo2));
39135 ss_VALIDATE_MEMORY(rts,blkInfo2);
39136 ssSetBlkInfo2Ptr(childS, blkInfo2);
39137 }
39138
39139 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
39140
39141# else
39142
39143 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
39144
39145# endif /* USE_RTMODEL */
39146
39147 /* Allocate memory of model methods 2 */
39148 {
39149 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
39150 malloc(sizeof(struct _ssSFcnModelMethods2));
39151 ss_VALIDATE_MEMORY(rts,methods2);
39152 ssSetModelMethods2(childS, methods2);
39153 }
39154
39155 /* Allocate memory of model methods 3 */
39156 {
39157 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
39158 malloc(sizeof(struct _ssSFcnModelMethods3));
39159 ss_VALIDATE_MEMORY(rts,methods3);
39160 ssSetModelMethods3(childS, methods3);
39161 }
39162
39163 /* Allocate memory for states auxilliary information */
39164 {
39165 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
39166 (sizeof(struct _ssStatesInfo2));
39167 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
39168 malloc(sizeof(ssPeriodicStatesInfo));
39169 ss_VALIDATE_MEMORY(rts,statesInfo2);
39170 ssSetStatesInfo2(childS, statesInfo2);
39171 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
39172 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
39173 }
39174
39175 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
39176 RegNumInputPorts);
39177 ssSetRegNumInputPortsFcnArg(childS,childS);
39178
39179 /* inputs */
39180 {
39181 struct _ssPortInputs *inputPortInfo =
39182 (struct _ssPortInputs *) calloc(1, sizeof(struct _ssPortInputs));
39183 ss_VALIDATE_MEMORY(rts,inputPortInfo);
39184 _ssSetNumInputPorts(childS, 1);
39185 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
39186
39187 /* port 0 */
39188 {
39189 real32_T const **sfcnUPtrs = (real32_T const **)
39190 malloc(1 * sizeof(real32_T *));
39191 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
39192 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
39193 ssGetLocalBlockIO(rts))->Sum2_n;
39194 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
39195 _ssSetInputPortNumDimensions(childS, 0, 1);
39196 ssSetInputPortWidth(childS, 0, 1);
39197 }
39198 }
39199
39200 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
39201 RegNumOutputPorts);
39202 ssSetRegNumOutputPortsFcnArg(childS,childS);
39203
39204 /* outputs */
39205 {
39206 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
39207 calloc(1, sizeof(struct _ssPortOutputs));
39208 ss_VALIDATE_MEMORY(rts,outputPortInfo);
39209 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
39210 _ssSetNumOutputPorts(childS, 1);
39211
39212 /* port 0 */
39213 {
39214 _ssSetOutputPortNumDimensions(childS, 0, 1);
39215 ssSetOutputPortWidth(childS, 0, 1);
39216 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
39217 ssGetLocalBlockIO(rts))->GeneratedSFunction_m5));
39218 }
39219 }
39220
39221 /* path info */
39222 _ssSetModelName(childS, "PositivePass_sf");
39223 _ssSetPath(childS,
39224 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /positive pass1/Generated S-Function");
39225 if (ssGetRTModel(rts) == (NULL)) {
39226 _ssSetParentSS(childS, rts);
39227 _ssSetRootSS(childS, ssGetRootSS(rts));
39228 } else {
39229 ssSetRTModel(childS,ssGetRTModel(rts));
39230 _ssSetParentSS(childS, (NULL));
39231 _ssSetRootSS(childS, childS);
39232 }
39233
39234 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
39235 (childS)->regDataType.arg1 = ((void *)(childS));
39236 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
39237 FcnSetErrorStatus);
39238 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
39239 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
39240 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
39241 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
39242
39243 /* registration */
39244#if defined(MATLAB_MEX_FILE)
39245
39246 {
39247 int_T i;
39248 mxArray *plhs[1];
39249 mxArray *prhs[4];
39250 double *pr;
39251 volatile int_T *intS = (int_T *)&childS;
39252 int_T addrlen = sizeof(SimStruct *);
39253 int_T m = addrlen/sizeof(int_T) + 1;
39254 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
39255 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
39256 pr = mxGetPr(prhs[1]);
39257 for (i = 0; i < m - 1; i++) {
39258 pr[i] = (double)intS[i];
39259 }
39260
39261 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
39262 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
39263 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
39264
39265 /* Reset port dimensions info functions because the S-function
39266 * and accelerator mex-files explicitly set their dimensions,
39267 * i.e., they are not dynamically sized. For this case, the
39268 * mex-file is responsible for the dimensions info memory
39269 * and Simulink should not free it. This is achieved by
39270 * setting the following two methods to NULL.
39271 */
39272 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
39273 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
39274
39275 /*
39276 * Setup function pointers and call mdlInitializeSizes via
39277 * simulink.c
39278 */
39279 mexCallMATLAB(1, plhs, 4, prhs, "PositivePass_sf");
39280 mxDestroyArray(plhs[0]);
39281 mxDestroyArray(prhs[0]);
39282 mxDestroyArray(prhs[1]);
39283 mxDestroyArray(prhs[2]);
39284 mxDestroyArray(prhs[3]);
39285 }
39286
39287#else
39288
39289 {
39290 PositivePass_sf(childS);
39291 sfcnInitializeSizes(childS);
39292 }
39293
39294#endif
39295
39296 sfcnInitializeSampleTimes(childS);
39297
39298 /* adjust sample time */
39299 ssSetSampleTime(childS, 0, 0.0);
39300 ssSetOffsetTime(childS, 0, 0.0);
39301 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
39302
39303 /* set compiled values of dynamic vector attributes */
39304 ssSetNumNonsampledZCs(childS, 0);
39305
39306 /* Update connectivity flags for each port */
39307 _ssSetInputPortConnected(childS, 0, 1);
39308 _ssSetOutputPortConnected(childS, 0, 1);
39309 _ssSetOutputPortBeingMerged(childS, 0, 0);
39310
39311 /* Update the BufferDstPort flags for each input port */
39312 _ssSetInputPortBufferDstPort(childS, 0, -1);
39313 }
39314
39315 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S271>/Generated S-Function (Gain_sf) */
39316 {
39317 SimStruct *childS = ssGetSFunction(rts, 149);
39318
39319 /* timing info */
39320 time_T *sfcnPeriod;
39321 time_T *sfcnOffset;
39322 int_T *sfcnTsMap;
39323 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
39324 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
39325 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
39326 ss_VALIDATE_MEMORY(rts,sfcnOffset);
39327 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
39328 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
39329 (void) memset((void*)sfcnPeriod, 0,
39330 sizeof(time_T)*1);
39331 (void) memset((void*)sfcnOffset, 0,
39332 sizeof(time_T)*1);
39333 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
39334 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
39335 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
39336
39337 /* Set up the mdlInfo pointer */
39338# ifdef USE_RTMODEL
39339
39340 {
39341 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
39342 struct _ssBlkInfo2));
39343 ss_VALIDATE_MEMORY(rts,blkInfo2);
39344 ssSetBlkInfo2Ptr(childS, blkInfo2);
39345 }
39346
39347 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
39348
39349# else
39350
39351 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
39352
39353# endif /* USE_RTMODEL */
39354
39355 /* Allocate memory of model methods 2 */
39356 {
39357 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
39358 malloc(sizeof(struct _ssSFcnModelMethods2));
39359 ss_VALIDATE_MEMORY(rts,methods2);
39360 ssSetModelMethods2(childS, methods2);
39361 }
39362
39363 /* Allocate memory of model methods 3 */
39364 {
39365 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
39366 malloc(sizeof(struct _ssSFcnModelMethods3));
39367 ss_VALIDATE_MEMORY(rts,methods3);
39368 ssSetModelMethods3(childS, methods3);
39369 }
39370
39371 /* Allocate memory for states auxilliary information */
39372 {
39373 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
39374 (sizeof(struct _ssStatesInfo2));
39375 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
39376 malloc(sizeof(ssPeriodicStatesInfo));
39377 ss_VALIDATE_MEMORY(rts,statesInfo2);
39378 ssSetStatesInfo2(childS, statesInfo2);
39379 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
39380 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
39381 }
39382
39383 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
39384 RegNumInputPorts);
39385 ssSetRegNumInputPortsFcnArg(childS,childS);
39386
39387 /* inputs */
39388 {
39389 struct _ssPortInputs *inputPortInfo =
39390 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
39391 ss_VALIDATE_MEMORY(rts,inputPortInfo);
39392 _ssSetNumInputPorts(childS, 2);
39393 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
39394
39395 /* port 0 */
39396 {
39397 real32_T const **sfcnUPtrs = (real32_T const **)
39398 malloc(1 * sizeof(real32_T *));
39399 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
39400 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
39401 ssGetLocalBlockIO(rts))->GeneratedSFunction_m5;
39402 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
39403 _ssSetInputPortNumDimensions(childS, 0, 1);
39404 ssSetInputPortWidth(childS, 0, 1);
39405 }
39406
39407 /* port 1 */
39408 {
39409 real32_T const **sfcnUPtrs = (real32_T const **)
39410 malloc(1 * sizeof(real32_T *));
39411 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
39412 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;
39413 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
39414 _ssSetInputPortNumDimensions(childS, 1, 1);
39415 ssSetInputPortWidth(childS, 1, 1);
39416 }
39417 }
39418
39419 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
39420 RegNumOutputPorts);
39421 ssSetRegNumOutputPortsFcnArg(childS,childS);
39422
39423 /* outputs */
39424 {
39425 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
39426 calloc(1, sizeof(struct _ssPortOutputs));
39427 ss_VALIDATE_MEMORY(rts,outputPortInfo);
39428 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
39429 _ssSetNumOutputPorts(childS, 1);
39430
39431 /* port 0 */
39432 {
39433 _ssSetOutputPortNumDimensions(childS, 0, 1);
39434 ssSetOutputPortWidth(childS, 0, 1);
39435 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
39436 ssGetLocalBlockIO(rts))->MinMax));
39437 }
39438 }
39439
39440 /* path info */
39441 _ssSetModelName(childS, "Gain_sf");
39442 _ssSetPath(childS,
39443 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/AlfaLim /gain9/Generated S-Function");
39444 if (ssGetRTModel(rts) == (NULL)) {
39445 _ssSetParentSS(childS, rts);
39446 _ssSetRootSS(childS, ssGetRootSS(rts));
39447 } else {
39448 ssSetRTModel(childS,ssGetRTModel(rts));
39449 _ssSetParentSS(childS, (NULL));
39450 _ssSetRootSS(childS, childS);
39451 }
39452
39453 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
39454 (childS)->regDataType.arg1 = ((void *)(childS));
39455 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
39456 FcnSetErrorStatus);
39457 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
39458 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
39459 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
39460 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
39461
39462 /* registration */
39463#if defined(MATLAB_MEX_FILE)
39464
39465 {
39466 int_T i;
39467 mxArray *plhs[1];
39468 mxArray *prhs[4];
39469 double *pr;
39470 volatile int_T *intS = (int_T *)&childS;
39471 int_T addrlen = sizeof(SimStruct *);
39472 int_T m = addrlen/sizeof(int_T) + 1;
39473 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
39474 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
39475 pr = mxGetPr(prhs[1]);
39476 for (i = 0; i < m - 1; i++) {
39477 pr[i] = (double)intS[i];
39478 }
39479
39480 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
39481 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
39482 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
39483
39484 /* Reset port dimensions info functions because the S-function
39485 * and accelerator mex-files explicitly set their dimensions,
39486 * i.e., they are not dynamically sized. For this case, the
39487 * mex-file is responsible for the dimensions info memory
39488 * and Simulink should not free it. This is achieved by
39489 * setting the following two methods to NULL.
39490 */
39491 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
39492 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
39493
39494 /*
39495 * Setup function pointers and call mdlInitializeSizes via
39496 * simulink.c
39497 */
39498 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
39499 mxDestroyArray(plhs[0]);
39500 mxDestroyArray(prhs[0]);
39501 mxDestroyArray(prhs[1]);
39502 mxDestroyArray(prhs[2]);
39503 mxDestroyArray(prhs[3]);
39504 }
39505
39506#else
39507
39508 {
39509 Gain_sf(childS);
39510 sfcnInitializeSizes(childS);
39511 }
39512
39513#endif
39514
39515 sfcnInitializeSampleTimes(childS);
39516
39517 /* adjust sample time */
39518 ssSetSampleTime(childS, 0, 0.0);
39519 ssSetOffsetTime(childS, 0, 0.0);
39520 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
39521
39522 /* set compiled values of dynamic vector attributes */
39523 ssSetNumNonsampledZCs(childS, 0);
39524
39525 /* Update connectivity flags for each port */
39526 _ssSetInputPortConnected(childS, 0, 1);
39527 _ssSetInputPortConnected(childS, 1, 1);
39528 _ssSetOutputPortConnected(childS, 0, 1);
39529 _ssSetOutputPortBeingMerged(childS, 0, 0);
39530
39531 /* Update the BufferDstPort flags for each input port */
39532 _ssSetInputPortBufferDstPort(childS, 0, -1);
39533 _ssSetInputPortBufferDstPort(childS, 1, -1);
39534 }
39535
39536 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S261>/Generated S-Function (Gain_sf) */
39537 {
39538 SimStruct *childS = ssGetSFunction(rts, 150);
39539
39540 /* timing info */
39541 time_T *sfcnPeriod;
39542 time_T *sfcnOffset;
39543 int_T *sfcnTsMap;
39544 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
39545 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
39546 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
39547 ss_VALIDATE_MEMORY(rts,sfcnOffset);
39548 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
39549 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
39550 (void) memset((void*)sfcnPeriod, 0,
39551 sizeof(time_T)*1);
39552 (void) memset((void*)sfcnOffset, 0,
39553 sizeof(time_T)*1);
39554 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
39555 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
39556 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
39557
39558 /* Set up the mdlInfo pointer */
39559# ifdef USE_RTMODEL
39560
39561 {
39562 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
39563 struct _ssBlkInfo2));
39564 ss_VALIDATE_MEMORY(rts,blkInfo2);
39565 ssSetBlkInfo2Ptr(childS, blkInfo2);
39566 }
39567
39568 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
39569
39570# else
39571
39572 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
39573
39574# endif /* USE_RTMODEL */
39575
39576 /* Allocate memory of model methods 2 */
39577 {
39578 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
39579 malloc(sizeof(struct _ssSFcnModelMethods2));
39580 ss_VALIDATE_MEMORY(rts,methods2);
39581 ssSetModelMethods2(childS, methods2);
39582 }
39583
39584 /* Allocate memory of model methods 3 */
39585 {
39586 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
39587 malloc(sizeof(struct _ssSFcnModelMethods3));
39588 ss_VALIDATE_MEMORY(rts,methods3);
39589 ssSetModelMethods3(childS, methods3);
39590 }
39591
39592 /* Allocate memory for states auxilliary information */
39593 {
39594 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
39595 (sizeof(struct _ssStatesInfo2));
39596 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
39597 malloc(sizeof(ssPeriodicStatesInfo));
39598 ss_VALIDATE_MEMORY(rts,statesInfo2);
39599 ssSetStatesInfo2(childS, statesInfo2);
39600 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
39601 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
39602 }
39603
39604 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
39605 RegNumInputPorts);
39606 ssSetRegNumInputPortsFcnArg(childS,childS);
39607
39608 /* inputs */
39609 {
39610 struct _ssPortInputs *inputPortInfo =
39611 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
39612 ss_VALIDATE_MEMORY(rts,inputPortInfo);
39613 _ssSetNumInputPorts(childS, 2);
39614 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
39615
39616 /* port 0 */
39617 {
39618 real32_T const **sfcnUPtrs = (real32_T const **)
39619 malloc(1 * sizeof(real32_T *));
39620 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
39621 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
39622 ssGetLocalBlockIO(rts))->GeneratedSFunction8_p;
39623 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
39624 _ssSetInputPortNumDimensions(childS, 0, 1);
39625 ssSetInputPortWidth(childS, 0, 1);
39626 }
39627
39628 /* port 1 */
39629 {
39630 real32_T const **sfcnUPtrs = (real32_T const **)
39631 malloc(1 * sizeof(real32_T *));
39632 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
39633 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
39634 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
39635 _ssSetInputPortNumDimensions(childS, 1, 1);
39636 ssSetInputPortWidth(childS, 1, 1);
39637 }
39638 }
39639
39640 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
39641 RegNumOutputPorts);
39642 ssSetRegNumOutputPortsFcnArg(childS,childS);
39643
39644 /* outputs */
39645 {
39646 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
39647 calloc(1, sizeof(struct _ssPortOutputs));
39648 ss_VALIDATE_MEMORY(rts,outputPortInfo);
39649 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
39650 _ssSetNumOutputPorts(childS, 1);
39651
39652 /* port 0 */
39653 {
39654 _ssSetOutputPortNumDimensions(childS, 0, 1);
39655 ssSetOutputPortWidth(childS, 0, 1);
39656 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
39657 ssGetLocalBlockIO(rts))->Saturation9));
39658 }
39659 }
39660
39661 /* path info */
39662 _ssSetModelName(childS, "Gain_sf");
39663 _ssSetPath(childS,
39664 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain2/Generated S-Function");
39665 if (ssGetRTModel(rts) == (NULL)) {
39666 _ssSetParentSS(childS, rts);
39667 _ssSetRootSS(childS, ssGetRootSS(rts));
39668 } else {
39669 ssSetRTModel(childS,ssGetRTModel(rts));
39670 _ssSetParentSS(childS, (NULL));
39671 _ssSetRootSS(childS, childS);
39672 }
39673
39674 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
39675 (childS)->regDataType.arg1 = ((void *)(childS));
39676 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
39677 FcnSetErrorStatus);
39678 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
39679 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
39680 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
39681 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
39682
39683 /* registration */
39684#if defined(MATLAB_MEX_FILE)
39685
39686 {
39687 int_T i;
39688 mxArray *plhs[1];
39689 mxArray *prhs[4];
39690 double *pr;
39691 volatile int_T *intS = (int_T *)&childS;
39692 int_T addrlen = sizeof(SimStruct *);
39693 int_T m = addrlen/sizeof(int_T) + 1;
39694 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
39695 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
39696 pr = mxGetPr(prhs[1]);
39697 for (i = 0; i < m - 1; i++) {
39698 pr[i] = (double)intS[i];
39699 }
39700
39701 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
39702 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
39703 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
39704
39705 /* Reset port dimensions info functions because the S-function
39706 * and accelerator mex-files explicitly set their dimensions,
39707 * i.e., they are not dynamically sized. For this case, the
39708 * mex-file is responsible for the dimensions info memory
39709 * and Simulink should not free it. This is achieved by
39710 * setting the following two methods to NULL.
39711 */
39712 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
39713 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
39714
39715 /*
39716 * Setup function pointers and call mdlInitializeSizes via
39717 * simulink.c
39718 */
39719 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
39720 mxDestroyArray(plhs[0]);
39721 mxDestroyArray(prhs[0]);
39722 mxDestroyArray(prhs[1]);
39723 mxDestroyArray(prhs[2]);
39724 mxDestroyArray(prhs[3]);
39725 }
39726
39727#else
39728
39729 {
39730 Gain_sf(childS);
39731 sfcnInitializeSizes(childS);
39732 }
39733
39734#endif
39735
39736 sfcnInitializeSampleTimes(childS);
39737
39738 /* adjust sample time */
39739 ssSetSampleTime(childS, 0, 0.0);
39740 ssSetOffsetTime(childS, 0, 0.0);
39741 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
39742
39743 /* set compiled values of dynamic vector attributes */
39744 ssSetNumNonsampledZCs(childS, 0);
39745
39746 /* Update connectivity flags for each port */
39747 _ssSetInputPortConnected(childS, 0, 1);
39748 _ssSetInputPortConnected(childS, 1, 1);
39749 _ssSetOutputPortConnected(childS, 0, 1);
39750 _ssSetOutputPortBeingMerged(childS, 0, 0);
39751
39752 /* Update the BufferDstPort flags for each input port */
39753 _ssSetInputPortBufferDstPort(childS, 0, -1);
39754 _ssSetInputPortBufferDstPort(childS, 1, -1);
39755 }
39756
39757 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S262>/Generated S-Function (Gain_sf) */
39758 {
39759 SimStruct *childS = ssGetSFunction(rts, 151);
39760
39761 /* timing info */
39762 time_T *sfcnPeriod;
39763 time_T *sfcnOffset;
39764 int_T *sfcnTsMap;
39765 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
39766 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
39767 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
39768 ss_VALIDATE_MEMORY(rts,sfcnOffset);
39769 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
39770 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
39771 (void) memset((void*)sfcnPeriod, 0,
39772 sizeof(time_T)*1);
39773 (void) memset((void*)sfcnOffset, 0,
39774 sizeof(time_T)*1);
39775 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
39776 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
39777 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
39778
39779 /* Set up the mdlInfo pointer */
39780# ifdef USE_RTMODEL
39781
39782 {
39783 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
39784 struct _ssBlkInfo2));
39785 ss_VALIDATE_MEMORY(rts,blkInfo2);
39786 ssSetBlkInfo2Ptr(childS, blkInfo2);
39787 }
39788
39789 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
39790
39791# else
39792
39793 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
39794
39795# endif /* USE_RTMODEL */
39796
39797 /* Allocate memory of model methods 2 */
39798 {
39799 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
39800 malloc(sizeof(struct _ssSFcnModelMethods2));
39801 ss_VALIDATE_MEMORY(rts,methods2);
39802 ssSetModelMethods2(childS, methods2);
39803 }
39804
39805 /* Allocate memory of model methods 3 */
39806 {
39807 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
39808 malloc(sizeof(struct _ssSFcnModelMethods3));
39809 ss_VALIDATE_MEMORY(rts,methods3);
39810 ssSetModelMethods3(childS, methods3);
39811 }
39812
39813 /* Allocate memory for states auxilliary information */
39814 {
39815 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
39816 (sizeof(struct _ssStatesInfo2));
39817 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
39818 malloc(sizeof(ssPeriodicStatesInfo));
39819 ss_VALIDATE_MEMORY(rts,statesInfo2);
39820 ssSetStatesInfo2(childS, statesInfo2);
39821 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
39822 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
39823 }
39824
39825 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
39826 RegNumInputPorts);
39827 ssSetRegNumInputPortsFcnArg(childS,childS);
39828
39829 /* inputs */
39830 {
39831 struct _ssPortInputs *inputPortInfo =
39832 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
39833 ss_VALIDATE_MEMORY(rts,inputPortInfo);
39834 _ssSetNumInputPorts(childS, 2);
39835 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
39836
39837 /* port 0 */
39838 {
39839 real32_T const **sfcnUPtrs = (real32_T const **)
39840 malloc(1 * sizeof(real32_T *));
39841 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
39842 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
39843 ssGetLocalBlockIO(rts))->Sum6_j;
39844 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
39845 _ssSetInputPortNumDimensions(childS, 0, 1);
39846 ssSetInputPortWidth(childS, 0, 1);
39847 }
39848
39849 /* port 1 */
39850 {
39851 real32_T const **sfcnUPtrs = (real32_T const **)
39852 malloc(1 * sizeof(real32_T *));
39853 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
39854 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
39855 ssGetLocalBlockIO(rts))->Product1_j;
39856 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
39857 _ssSetInputPortNumDimensions(childS, 1, 1);
39858 ssSetInputPortWidth(childS, 1, 1);
39859 }
39860 }
39861
39862 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
39863 RegNumOutputPorts);
39864 ssSetRegNumOutputPortsFcnArg(childS,childS);
39865
39866 /* outputs */
39867 {
39868 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
39869 calloc(1, sizeof(struct _ssPortOutputs));
39870 ss_VALIDATE_MEMORY(rts,outputPortInfo);
39871 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
39872 _ssSetNumOutputPorts(childS, 1);
39873
39874 /* port 0 */
39875 {
39876 _ssSetOutputPortNumDimensions(childS, 0, 1);
39877 ssSetOutputPortWidth(childS, 0, 1);
39878 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
39879 ssGetLocalBlockIO(rts))->GeneratedSFunction_l));
39880 }
39881 }
39882
39883 /* path info */
39884 _ssSetModelName(childS, "Gain_sf");
39885 _ssSetPath(childS,
39886 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain3/Generated S-Function");
39887 if (ssGetRTModel(rts) == (NULL)) {
39888 _ssSetParentSS(childS, rts);
39889 _ssSetRootSS(childS, ssGetRootSS(rts));
39890 } else {
39891 ssSetRTModel(childS,ssGetRTModel(rts));
39892 _ssSetParentSS(childS, (NULL));
39893 _ssSetRootSS(childS, childS);
39894 }
39895
39896 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
39897 (childS)->regDataType.arg1 = ((void *)(childS));
39898 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
39899 FcnSetErrorStatus);
39900 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
39901 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
39902 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
39903 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
39904
39905 /* registration */
39906#if defined(MATLAB_MEX_FILE)
39907
39908 {
39909 int_T i;
39910 mxArray *plhs[1];
39911 mxArray *prhs[4];
39912 double *pr;
39913 volatile int_T *intS = (int_T *)&childS;
39914 int_T addrlen = sizeof(SimStruct *);
39915 int_T m = addrlen/sizeof(int_T) + 1;
39916 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
39917 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
39918 pr = mxGetPr(prhs[1]);
39919 for (i = 0; i < m - 1; i++) {
39920 pr[i] = (double)intS[i];
39921 }
39922
39923 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
39924 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
39925 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
39926
39927 /* Reset port dimensions info functions because the S-function
39928 * and accelerator mex-files explicitly set their dimensions,
39929 * i.e., they are not dynamically sized. For this case, the
39930 * mex-file is responsible for the dimensions info memory
39931 * and Simulink should not free it. This is achieved by
39932 * setting the following two methods to NULL.
39933 */
39934 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
39935 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
39936
39937 /*
39938 * Setup function pointers and call mdlInitializeSizes via
39939 * simulink.c
39940 */
39941 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
39942 mxDestroyArray(plhs[0]);
39943 mxDestroyArray(prhs[0]);
39944 mxDestroyArray(prhs[1]);
39945 mxDestroyArray(prhs[2]);
39946 mxDestroyArray(prhs[3]);
39947 }
39948
39949#else
39950
39951 {
39952 Gain_sf(childS);
39953 sfcnInitializeSizes(childS);
39954 }
39955
39956#endif
39957
39958 sfcnInitializeSampleTimes(childS);
39959
39960 /* adjust sample time */
39961 ssSetSampleTime(childS, 0, 0.0);
39962 ssSetOffsetTime(childS, 0, 0.0);
39963 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
39964
39965 /* set compiled values of dynamic vector attributes */
39966 ssSetNumNonsampledZCs(childS, 0);
39967
39968 /* Update connectivity flags for each port */
39969 _ssSetInputPortConnected(childS, 0, 1);
39970 _ssSetInputPortConnected(childS, 1, 1);
39971 _ssSetOutputPortConnected(childS, 0, 1);
39972 _ssSetOutputPortBeingMerged(childS, 0, 0);
39973
39974 /* Update the BufferDstPort flags for each input port */
39975 _ssSetInputPortBufferDstPort(childS, 0, -1);
39976 _ssSetInputPortBufferDstPort(childS, 1, -1);
39977 }
39978
39979 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S258>/Generated S-Function1 (SaturationLimiter_sf) */
39980 {
39981 SimStruct *childS = ssGetSFunction(rts, 152);
39982
39983 /* timing info */
39984 time_T *sfcnPeriod;
39985 time_T *sfcnOffset;
39986 int_T *sfcnTsMap;
39987 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
39988 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
39989 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
39990 ss_VALIDATE_MEMORY(rts,sfcnOffset);
39991 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
39992 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
39993 (void) memset((void*)sfcnPeriod, 0,
39994 sizeof(time_T)*1);
39995 (void) memset((void*)sfcnOffset, 0,
39996 sizeof(time_T)*1);
39997 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
39998 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
39999 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
40000
40001 /* Set up the mdlInfo pointer */
40002# ifdef USE_RTMODEL
40003
40004 {
40005 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
40006 struct _ssBlkInfo2));
40007 ss_VALIDATE_MEMORY(rts,blkInfo2);
40008 ssSetBlkInfo2Ptr(childS, blkInfo2);
40009 }
40010
40011 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
40012
40013# else
40014
40015 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
40016
40017# endif /* USE_RTMODEL */
40018
40019 /* Allocate memory of model methods 2 */
40020 {
40021 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
40022 malloc(sizeof(struct _ssSFcnModelMethods2));
40023 ss_VALIDATE_MEMORY(rts,methods2);
40024 ssSetModelMethods2(childS, methods2);
40025 }
40026
40027 /* Allocate memory of model methods 3 */
40028 {
40029 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
40030 malloc(sizeof(struct _ssSFcnModelMethods3));
40031 ss_VALIDATE_MEMORY(rts,methods3);
40032 ssSetModelMethods3(childS, methods3);
40033 }
40034
40035 /* Allocate memory for states auxilliary information */
40036 {
40037 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
40038 (sizeof(struct _ssStatesInfo2));
40039 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
40040 malloc(sizeof(ssPeriodicStatesInfo));
40041 ss_VALIDATE_MEMORY(rts,statesInfo2);
40042 ssSetStatesInfo2(childS, statesInfo2);
40043 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
40044 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
40045 }
40046
40047 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
40048 RegNumInputPorts);
40049 ssSetRegNumInputPortsFcnArg(childS,childS);
40050
40051 /* inputs */
40052 {
40053 struct _ssPortInputs *inputPortInfo =
40054 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
40055 ss_VALIDATE_MEMORY(rts,inputPortInfo);
40056 _ssSetNumInputPorts(childS, 3);
40057 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
40058
40059 /* port 0 */
40060 {
40061 real32_T const **sfcnUPtrs = (real32_T const **)
40062 malloc(1 * sizeof(real32_T *));
40063 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40064 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
40065 ssGetLocalBlockIO(rts))->GeneratedSFunction_l;
40066 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
40067 _ssSetInputPortNumDimensions(childS, 0, 1);
40068 ssSetInputPortWidth(childS, 0, 1);
40069 }
40070
40071 /* port 1 */
40072 {
40073 real32_T const **sfcnUPtrs = (real32_T const **)
40074 malloc(1 * sizeof(real32_T *));
40075 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40076 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled130;
40077 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
40078 _ssSetInputPortNumDimensions(childS, 1, 1);
40079 ssSetInputPortWidth(childS, 1, 1);
40080 }
40081
40082 /* port 2 */
40083 {
40084 real32_T const **sfcnUPtrs = (real32_T const **)
40085 malloc(1 * sizeof(real32_T *));
40086 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40087 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled131;
40088 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
40089 _ssSetInputPortNumDimensions(childS, 2, 1);
40090 ssSetInputPortWidth(childS, 2, 1);
40091 }
40092 }
40093
40094 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
40095 RegNumOutputPorts);
40096 ssSetRegNumOutputPortsFcnArg(childS,childS);
40097
40098 /* outputs */
40099 {
40100 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
40101 calloc(1, sizeof(struct _ssPortOutputs));
40102 ss_VALIDATE_MEMORY(rts,outputPortInfo);
40103 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
40104 _ssSetNumOutputPorts(childS, 1);
40105
40106 /* port 0 */
40107 {
40108 _ssSetOutputPortNumDimensions(childS, 0, 1);
40109 ssSetOutputPortWidth(childS, 0, 1);
40110 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
40111 ssGetLocalBlockIO(rts))->Saturation9));
40112 }
40113 }
40114
40115 /* path info */
40116 _ssSetModelName(childS, "SaturationLimiter_sf");
40117 _ssSetPath(childS,
40118 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/Saturation Limiter1/Generated S-Function1");
40119 if (ssGetRTModel(rts) == (NULL)) {
40120 _ssSetParentSS(childS, rts);
40121 _ssSetRootSS(childS, ssGetRootSS(rts));
40122 } else {
40123 ssSetRTModel(childS,ssGetRTModel(rts));
40124 _ssSetParentSS(childS, (NULL));
40125 _ssSetRootSS(childS, childS);
40126 }
40127
40128 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
40129 (childS)->regDataType.arg1 = ((void *)(childS));
40130 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
40131 FcnSetErrorStatus);
40132 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
40133 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
40134 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
40135 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
40136
40137 /* registration */
40138#if defined(MATLAB_MEX_FILE)
40139
40140 {
40141 int_T i;
40142 mxArray *plhs[1];
40143 mxArray *prhs[4];
40144 double *pr;
40145 volatile int_T *intS = (int_T *)&childS;
40146 int_T addrlen = sizeof(SimStruct *);
40147 int_T m = addrlen/sizeof(int_T) + 1;
40148 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
40149 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
40150 pr = mxGetPr(prhs[1]);
40151 for (i = 0; i < m - 1; i++) {
40152 pr[i] = (double)intS[i];
40153 }
40154
40155 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
40156 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
40157 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
40158
40159 /* Reset port dimensions info functions because the S-function
40160 * and accelerator mex-files explicitly set their dimensions,
40161 * i.e., they are not dynamically sized. For this case, the
40162 * mex-file is responsible for the dimensions info memory
40163 * and Simulink should not free it. This is achieved by
40164 * setting the following two methods to NULL.
40165 */
40166 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
40167 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
40168
40169 /*
40170 * Setup function pointers and call mdlInitializeSizes via
40171 * simulink.c
40172 */
40173 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
40174 mxDestroyArray(plhs[0]);
40175 mxDestroyArray(prhs[0]);
40176 mxDestroyArray(prhs[1]);
40177 mxDestroyArray(prhs[2]);
40178 mxDestroyArray(prhs[3]);
40179 }
40180
40181#else
40182
40183 {
40184 SaturationLimiter_sf(childS);
40185 sfcnInitializeSizes(childS);
40186 }
40187
40188#endif
40189
40190 sfcnInitializeSampleTimes(childS);
40191
40192 /* adjust sample time */
40193 ssSetSampleTime(childS, 0, 0.0);
40194 ssSetOffsetTime(childS, 0, 0.0);
40195 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
40196
40197 /* set compiled values of dynamic vector attributes */
40198 ssSetNumNonsampledZCs(childS, 0);
40199
40200 /* Update connectivity flags for each port */
40201 _ssSetInputPortConnected(childS, 0, 1);
40202 _ssSetInputPortConnected(childS, 1, 1);
40203 _ssSetInputPortConnected(childS, 2, 1);
40204 _ssSetOutputPortConnected(childS, 0, 1);
40205 _ssSetOutputPortBeingMerged(childS, 0, 0);
40206
40207 /* Update the BufferDstPort flags for each input port */
40208 _ssSetInputPortBufferDstPort(childS, 0, -1);
40209 _ssSetInputPortBufferDstPort(childS, 1, -1);
40210 _ssSetInputPortBufferDstPort(childS, 2, -1);
40211 }
40212
40213 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S263>/Generated S-Function (Gain_sf) */
40214 {
40215 SimStruct *childS = ssGetSFunction(rts, 153);
40216
40217 /* timing info */
40218 time_T *sfcnPeriod;
40219 time_T *sfcnOffset;
40220 int_T *sfcnTsMap;
40221 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
40222 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
40223 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
40224 ss_VALIDATE_MEMORY(rts,sfcnOffset);
40225 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
40226 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
40227 (void) memset((void*)sfcnPeriod, 0,
40228 sizeof(time_T)*1);
40229 (void) memset((void*)sfcnOffset, 0,
40230 sizeof(time_T)*1);
40231 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
40232 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
40233 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
40234
40235 /* Set up the mdlInfo pointer */
40236# ifdef USE_RTMODEL
40237
40238 {
40239 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
40240 struct _ssBlkInfo2));
40241 ss_VALIDATE_MEMORY(rts,blkInfo2);
40242 ssSetBlkInfo2Ptr(childS, blkInfo2);
40243 }
40244
40245 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
40246
40247# else
40248
40249 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
40250
40251# endif /* USE_RTMODEL */
40252
40253 /* Allocate memory of model methods 2 */
40254 {
40255 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
40256 malloc(sizeof(struct _ssSFcnModelMethods2));
40257 ss_VALIDATE_MEMORY(rts,methods2);
40258 ssSetModelMethods2(childS, methods2);
40259 }
40260
40261 /* Allocate memory of model methods 3 */
40262 {
40263 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
40264 malloc(sizeof(struct _ssSFcnModelMethods3));
40265 ss_VALIDATE_MEMORY(rts,methods3);
40266 ssSetModelMethods3(childS, methods3);
40267 }
40268
40269 /* Allocate memory for states auxilliary information */
40270 {
40271 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
40272 (sizeof(struct _ssStatesInfo2));
40273 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
40274 malloc(sizeof(ssPeriodicStatesInfo));
40275 ss_VALIDATE_MEMORY(rts,statesInfo2);
40276 ssSetStatesInfo2(childS, statesInfo2);
40277 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
40278 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
40279 }
40280
40281 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
40282 RegNumInputPorts);
40283 ssSetRegNumInputPortsFcnArg(childS,childS);
40284
40285 /* inputs */
40286 {
40287 struct _ssPortInputs *inputPortInfo =
40288 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
40289 ss_VALIDATE_MEMORY(rts,inputPortInfo);
40290 _ssSetNumInputPorts(childS, 2);
40291 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
40292
40293 /* port 0 */
40294 {
40295 real32_T const **sfcnUPtrs = (real32_T const **)
40296 malloc(1 * sizeof(real32_T *));
40297 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40298 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
40299 ssGetLocalBlockIO(rts))->GeneratedSFunction_l;
40300 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
40301 _ssSetInputPortNumDimensions(childS, 0, 1);
40302 ssSetInputPortWidth(childS, 0, 1);
40303 }
40304
40305 /* port 1 */
40306 {
40307 real32_T const **sfcnUPtrs = (real32_T const **)
40308 malloc(1 * sizeof(real32_T *));
40309 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40310 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled132;
40311 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
40312 _ssSetInputPortNumDimensions(childS, 1, 1);
40313 ssSetInputPortWidth(childS, 1, 1);
40314 }
40315 }
40316
40317 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
40318 RegNumOutputPorts);
40319 ssSetRegNumOutputPortsFcnArg(childS,childS);
40320
40321 /* outputs */
40322 {
40323 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
40324 calloc(1, sizeof(struct _ssPortOutputs));
40325 ss_VALIDATE_MEMORY(rts,outputPortInfo);
40326 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
40327 _ssSetNumOutputPorts(childS, 1);
40328
40329 /* port 0 */
40330 {
40331 _ssSetOutputPortNumDimensions(childS, 0, 1);
40332 ssSetOutputPortWidth(childS, 0, 1);
40333 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
40334 ssGetLocalBlockIO(rts))->Saturation9));
40335 }
40336 }
40337
40338 /* path info */
40339 _ssSetModelName(childS, "Gain_sf");
40340 _ssSetPath(childS,
40341 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain4/Generated S-Function");
40342 if (ssGetRTModel(rts) == (NULL)) {
40343 _ssSetParentSS(childS, rts);
40344 _ssSetRootSS(childS, ssGetRootSS(rts));
40345 } else {
40346 ssSetRTModel(childS,ssGetRTModel(rts));
40347 _ssSetParentSS(childS, (NULL));
40348 _ssSetRootSS(childS, childS);
40349 }
40350
40351 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
40352 (childS)->regDataType.arg1 = ((void *)(childS));
40353 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
40354 FcnSetErrorStatus);
40355 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
40356 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
40357 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
40358 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
40359
40360 /* registration */
40361#if defined(MATLAB_MEX_FILE)
40362
40363 {
40364 int_T i;
40365 mxArray *plhs[1];
40366 mxArray *prhs[4];
40367 double *pr;
40368 volatile int_T *intS = (int_T *)&childS;
40369 int_T addrlen = sizeof(SimStruct *);
40370 int_T m = addrlen/sizeof(int_T) + 1;
40371 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
40372 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
40373 pr = mxGetPr(prhs[1]);
40374 for (i = 0; i < m - 1; i++) {
40375 pr[i] = (double)intS[i];
40376 }
40377
40378 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
40379 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
40380 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
40381
40382 /* Reset port dimensions info functions because the S-function
40383 * and accelerator mex-files explicitly set their dimensions,
40384 * i.e., they are not dynamically sized. For this case, the
40385 * mex-file is responsible for the dimensions info memory
40386 * and Simulink should not free it. This is achieved by
40387 * setting the following two methods to NULL.
40388 */
40389 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
40390 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
40391
40392 /*
40393 * Setup function pointers and call mdlInitializeSizes via
40394 * simulink.c
40395 */
40396 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
40397 mxDestroyArray(plhs[0]);
40398 mxDestroyArray(prhs[0]);
40399 mxDestroyArray(prhs[1]);
40400 mxDestroyArray(prhs[2]);
40401 mxDestroyArray(prhs[3]);
40402 }
40403
40404#else
40405
40406 {
40407 Gain_sf(childS);
40408 sfcnInitializeSizes(childS);
40409 }
40410
40411#endif
40412
40413 sfcnInitializeSampleTimes(childS);
40414
40415 /* adjust sample time */
40416 ssSetSampleTime(childS, 0, 0.0);
40417 ssSetOffsetTime(childS, 0, 0.0);
40418 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
40419
40420 /* set compiled values of dynamic vector attributes */
40421 ssSetNumNonsampledZCs(childS, 0);
40422
40423 /* Update connectivity flags for each port */
40424 _ssSetInputPortConnected(childS, 0, 1);
40425 _ssSetInputPortConnected(childS, 1, 1);
40426 _ssSetOutputPortConnected(childS, 0, 1);
40427 _ssSetOutputPortBeingMerged(childS, 0, 0);
40428
40429 /* Update the BufferDstPort flags for each input port */
40430 _ssSetInputPortBufferDstPort(childS, 0, -1);
40431 _ssSetInputPortBufferDstPort(childS, 1, -1);
40432 }
40433
40434 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S264>/Generated S-Function (Gain_sf) */
40435 {
40436 SimStruct *childS = ssGetSFunction(rts, 154);
40437
40438 /* timing info */
40439 time_T *sfcnPeriod;
40440 time_T *sfcnOffset;
40441 int_T *sfcnTsMap;
40442 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
40443 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
40444 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
40445 ss_VALIDATE_MEMORY(rts,sfcnOffset);
40446 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
40447 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
40448 (void) memset((void*)sfcnPeriod, 0,
40449 sizeof(time_T)*1);
40450 (void) memset((void*)sfcnOffset, 0,
40451 sizeof(time_T)*1);
40452 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
40453 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
40454 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
40455
40456 /* Set up the mdlInfo pointer */
40457# ifdef USE_RTMODEL
40458
40459 {
40460 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
40461 struct _ssBlkInfo2));
40462 ss_VALIDATE_MEMORY(rts,blkInfo2);
40463 ssSetBlkInfo2Ptr(childS, blkInfo2);
40464 }
40465
40466 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
40467
40468# else
40469
40470 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
40471
40472# endif /* USE_RTMODEL */
40473
40474 /* Allocate memory of model methods 2 */
40475 {
40476 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
40477 malloc(sizeof(struct _ssSFcnModelMethods2));
40478 ss_VALIDATE_MEMORY(rts,methods2);
40479 ssSetModelMethods2(childS, methods2);
40480 }
40481
40482 /* Allocate memory of model methods 3 */
40483 {
40484 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
40485 malloc(sizeof(struct _ssSFcnModelMethods3));
40486 ss_VALIDATE_MEMORY(rts,methods3);
40487 ssSetModelMethods3(childS, methods3);
40488 }
40489
40490 /* Allocate memory for states auxilliary information */
40491 {
40492 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
40493 (sizeof(struct _ssStatesInfo2));
40494 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
40495 malloc(sizeof(ssPeriodicStatesInfo));
40496 ss_VALIDATE_MEMORY(rts,statesInfo2);
40497 ssSetStatesInfo2(childS, statesInfo2);
40498 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
40499 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
40500 }
40501
40502 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
40503 RegNumInputPorts);
40504 ssSetRegNumInputPortsFcnArg(childS,childS);
40505
40506 /* inputs */
40507 {
40508 struct _ssPortInputs *inputPortInfo =
40509 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
40510 ss_VALIDATE_MEMORY(rts,inputPortInfo);
40511 _ssSetNumInputPorts(childS, 2);
40512 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
40513
40514 /* port 0 */
40515 {
40516 real32_T const **sfcnUPtrs = (real32_T const **)
40517 malloc(1 * sizeof(real32_T *));
40518 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40519 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
40520 ssGetLocalBlockIO(rts))->UnitDelay1_c;
40521 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
40522 _ssSetInputPortNumDimensions(childS, 0, 1);
40523 ssSetInputPortWidth(childS, 0, 1);
40524 }
40525
40526 /* port 1 */
40527 {
40528 real32_T const **sfcnUPtrs = (real32_T const **)
40529 malloc(1 * sizeof(real32_T *));
40530 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40531 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
40532 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
40533 _ssSetInputPortNumDimensions(childS, 1, 1);
40534 ssSetInputPortWidth(childS, 1, 1);
40535 }
40536 }
40537
40538 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
40539 RegNumOutputPorts);
40540 ssSetRegNumOutputPortsFcnArg(childS,childS);
40541
40542 /* outputs */
40543 {
40544 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
40545 calloc(1, sizeof(struct _ssPortOutputs));
40546 ss_VALIDATE_MEMORY(rts,outputPortInfo);
40547 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
40548 _ssSetNumOutputPorts(childS, 1);
40549
40550 /* port 0 */
40551 {
40552 _ssSetOutputPortNumDimensions(childS, 0, 1);
40553 ssSetOutputPortWidth(childS, 0, 1);
40554 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
40555 ssGetLocalBlockIO(rts))->GeneratedSFunction_mt));
40556 }
40557 }
40558
40559 /* path info */
40560 _ssSetModelName(childS, "Gain_sf");
40561 _ssSetPath(childS,
40562 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/gain8/Generated S-Function");
40563 if (ssGetRTModel(rts) == (NULL)) {
40564 _ssSetParentSS(childS, rts);
40565 _ssSetRootSS(childS, ssGetRootSS(rts));
40566 } else {
40567 ssSetRTModel(childS,ssGetRTModel(rts));
40568 _ssSetParentSS(childS, (NULL));
40569 _ssSetRootSS(childS, childS);
40570 }
40571
40572 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
40573 (childS)->regDataType.arg1 = ((void *)(childS));
40574 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
40575 FcnSetErrorStatus);
40576 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
40577 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
40578 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
40579 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
40580
40581 /* registration */
40582#if defined(MATLAB_MEX_FILE)
40583
40584 {
40585 int_T i;
40586 mxArray *plhs[1];
40587 mxArray *prhs[4];
40588 double *pr;
40589 volatile int_T *intS = (int_T *)&childS;
40590 int_T addrlen = sizeof(SimStruct *);
40591 int_T m = addrlen/sizeof(int_T) + 1;
40592 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
40593 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
40594 pr = mxGetPr(prhs[1]);
40595 for (i = 0; i < m - 1; i++) {
40596 pr[i] = (double)intS[i];
40597 }
40598
40599 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
40600 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
40601 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
40602
40603 /* Reset port dimensions info functions because the S-function
40604 * and accelerator mex-files explicitly set their dimensions,
40605 * i.e., they are not dynamically sized. For this case, the
40606 * mex-file is responsible for the dimensions info memory
40607 * and Simulink should not free it. This is achieved by
40608 * setting the following two methods to NULL.
40609 */
40610 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
40611 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
40612
40613 /*
40614 * Setup function pointers and call mdlInitializeSizes via
40615 * simulink.c
40616 */
40617 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
40618 mxDestroyArray(plhs[0]);
40619 mxDestroyArray(prhs[0]);
40620 mxDestroyArray(prhs[1]);
40621 mxDestroyArray(prhs[2]);
40622 mxDestroyArray(prhs[3]);
40623 }
40624
40625#else
40626
40627 {
40628 Gain_sf(childS);
40629 sfcnInitializeSizes(childS);
40630 }
40631
40632#endif
40633
40634 sfcnInitializeSampleTimes(childS);
40635
40636 /* adjust sample time */
40637 ssSetSampleTime(childS, 0, 0.005);
40638 ssSetOffsetTime(childS, 0, 0.0);
40639 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[1];
40640
40641 /* set compiled values of dynamic vector attributes */
40642 ssSetNumNonsampledZCs(childS, 0);
40643
40644 /* Update connectivity flags for each port */
40645 _ssSetInputPortConnected(childS, 0, 1);
40646 _ssSetInputPortConnected(childS, 1, 1);
40647 _ssSetOutputPortConnected(childS, 0, 1);
40648 _ssSetOutputPortBeingMerged(childS, 0, 0);
40649
40650 /* Update the BufferDstPort flags for each input port */
40651 _ssSetInputPortBufferDstPort(childS, 0, -1);
40652 _ssSetInputPortBufferDstPort(childS, 1, -1);
40653 }
40654
40655 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S257>/Generated S-Function3 (IntegratorLimited_sf) */
40656 {
40657 SimStruct *childS = ssGetSFunction(rts, 155);
40658
40659 /* timing info */
40660 time_T *sfcnPeriod;
40661 time_T *sfcnOffset;
40662 int_T *sfcnTsMap;
40663 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
40664 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
40665 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
40666 ss_VALIDATE_MEMORY(rts,sfcnOffset);
40667 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
40668 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
40669 (void) memset((void*)sfcnPeriod, 0,
40670 sizeof(time_T)*1);
40671 (void) memset((void*)sfcnOffset, 0,
40672 sizeof(time_T)*1);
40673 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
40674 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
40675 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
40676
40677 /* Set up the mdlInfo pointer */
40678# ifdef USE_RTMODEL
40679
40680 {
40681 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
40682 struct _ssBlkInfo2));
40683 ss_VALIDATE_MEMORY(rts,blkInfo2);
40684 ssSetBlkInfo2Ptr(childS, blkInfo2);
40685 }
40686
40687 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
40688
40689# else
40690
40691 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
40692
40693# endif /* USE_RTMODEL */
40694
40695 /* Allocate memory of model methods 2 */
40696 {
40697 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
40698 malloc(sizeof(struct _ssSFcnModelMethods2));
40699 ss_VALIDATE_MEMORY(rts,methods2);
40700 ssSetModelMethods2(childS, methods2);
40701 }
40702
40703 /* Allocate memory of model methods 3 */
40704 {
40705 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
40706 malloc(sizeof(struct _ssSFcnModelMethods3));
40707 ss_VALIDATE_MEMORY(rts,methods3);
40708 ssSetModelMethods3(childS, methods3);
40709 }
40710
40711 /* Allocate memory for states auxilliary information */
40712 {
40713 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
40714 (sizeof(struct _ssStatesInfo2));
40715 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
40716 malloc(sizeof(ssPeriodicStatesInfo));
40717 ss_VALIDATE_MEMORY(rts,statesInfo2);
40718 ssSetStatesInfo2(childS, statesInfo2);
40719 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
40720 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
40721 }
40722
40723 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
40724 RegNumInputPorts);
40725 ssSetRegNumInputPortsFcnArg(childS,childS);
40726
40727 /* inputs */
40728 {
40729 struct _ssPortInputs *inputPortInfo =
40730 (struct _ssPortInputs *) calloc(7, sizeof(struct _ssPortInputs));
40731 ss_VALIDATE_MEMORY(rts,inputPortInfo);
40732 _ssSetNumInputPorts(childS, 7);
40733 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
40734
40735 /* port 0 */
40736 {
40737 real32_T const **sfcnUPtrs = (real32_T const **)
40738 malloc(1 * sizeof(real32_T *));
40739 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40740 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
40741 ssGetLocalBlockIO(rts))->dtCAS;
40742 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
40743 _ssSetInputPortNumDimensions(childS, 0, 1);
40744 ssSetInputPortWidth(childS, 0, 1);
40745 }
40746
40747 /* port 1 */
40748 {
40749 int8_T const **sfcnUPtrs = (int8_T const **)
40750 malloc(1 * sizeof(int8_T *));
40751 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40752 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
40753 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
40754 _ssSetInputPortNumDimensions(childS, 1, 1);
40755 ssSetInputPortWidth(childS, 1, 1);
40756 }
40757
40758 /* port 2 */
40759 {
40760 real32_T const **sfcnUPtrs = (real32_T const **)
40761 malloc(1 * sizeof(real32_T *));
40762 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40763 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
40764 ssGetLocalBlockIO(rts))->Sum4_iv;
40765 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
40766 _ssSetInputPortNumDimensions(childS, 2, 1);
40767 ssSetInputPortWidth(childS, 2, 1);
40768 }
40769
40770 /* port 3 */
40771 {
40772 real32_T const **sfcnUPtrs = (real32_T const **)
40773 malloc(1 * sizeof(real32_T *));
40774 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40775 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
40776 ssGetLocalBlockIO(rts))->Sum4_iv;
40777 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
40778 _ssSetInputPortNumDimensions(childS, 3, 1);
40779 ssSetInputPortWidth(childS, 3, 1);
40780 }
40781
40782 /* port 4 */
40783 {
40784 real32_T const **sfcnUPtrs = (real32_T const **)
40785 malloc(1 * sizeof(real32_T *));
40786 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40787 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
40788 ssGetLocalBlockIO(rts))->Add4;
40789 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
40790 _ssSetInputPortNumDimensions(childS, 4, 1);
40791 ssSetInputPortWidth(childS, 4, 1);
40792 }
40793
40794 /* port 5 */
40795 {
40796 real32_T const **sfcnUPtrs = (real32_T const **)
40797 malloc(1 * sizeof(real32_T *));
40798 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40799 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
40800 ssGetLocalBlockIO(rts))->Add5;
40801 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
40802 _ssSetInputPortNumDimensions(childS, 5, 1);
40803 ssSetInputPortWidth(childS, 5, 1);
40804 }
40805
40806 /* port 6 */
40807 {
40808 real32_T const **sfcnUPtrs = (real32_T const **)
40809 malloc(1 * sizeof(real32_T *));
40810 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
40811 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
40812 ssGetLocalBlockIO(rts))->Sum11_c;
40813 _ssSetInputPortSignalPtrs(childS, 6, (InputPtrsType)&sfcnUPtrs[0]);
40814 _ssSetInputPortNumDimensions(childS, 6, 1);
40815 ssSetInputPortWidth(childS, 6, 1);
40816 }
40817 }
40818
40819 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
40820 RegNumOutputPorts);
40821 ssSetRegNumOutputPortsFcnArg(childS,childS);
40822
40823 /* outputs */
40824 {
40825 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
40826 calloc(1, sizeof(struct _ssPortOutputs));
40827 ss_VALIDATE_MEMORY(rts,outputPortInfo);
40828 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
40829 _ssSetNumOutputPorts(childS, 1);
40830
40831 /* port 0 */
40832 {
40833 _ssSetOutputPortNumDimensions(childS, 0, 1);
40834 ssSetOutputPortWidth(childS, 0, 1);
40835 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
40836 ssGetLocalBlockIO(rts))->deint));
40837 }
40838 }
40839
40840 /* path info */
40841 _ssSetModelName(childS, "IntegratorLimited_sf");
40842 _ssSetPath(childS,
40843 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/PIDonControl/Integrator Limited/Generated S-Function3");
40844 if (ssGetRTModel(rts) == (NULL)) {
40845 _ssSetParentSS(childS, rts);
40846 _ssSetRootSS(childS, ssGetRootSS(rts));
40847 } else {
40848 ssSetRTModel(childS,ssGetRTModel(rts));
40849 _ssSetParentSS(childS, (NULL));
40850 _ssSetRootSS(childS, childS);
40851 }
40852
40853 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
40854
40855 /* work vectors */
40856 {
40857 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
40858 (4 * sizeof(struct _ssDWorkRecord));
40859 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
40860 calloc(4, sizeof(struct _ssDWorkAuxRecord));
40861 ss_VALIDATE_MEMORY(rts,dWorkRecord);
40862 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
40863 ssSetSFcnDWork(childS, dWorkRecord);
40864 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
40865 _ssSetNumDWork(childS, 4);
40866
40867 /* DWORK0 */
40868 ssSetDWorkWidth(childS, 0, 1);
40869 ssSetDWorkDataType(childS, 0,SS_SINGLE);
40870 ssSetDWorkComplexSignal(childS, 0, 0);
40871 ssSetDWorkUsedAsDState(childS, 0, 1);
40872 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 263))[0]);
40873
40874 /* DWORK1 */
40875 ssSetDWorkWidth(childS, 1, 1);
40876 ssSetDWorkDataType(childS, 1,SS_SINGLE);
40877 ssSetDWorkComplexSignal(childS, 1, 0);
40878 ssSetDWorkUsedAsDState(childS, 1, 1);
40879 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 264))[0]);
40880
40881 /* DWORK2 */
40882 ssSetDWorkWidth(childS, 2, 1);
40883 ssSetDWorkDataType(childS, 2,SS_INT8);
40884 ssSetDWorkComplexSignal(childS, 2, 0);
40885 ssSetDWorkUsedAsDState(childS, 2, 1);
40886 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 492))[0]);
40887
40888 /* DWORK3 */
40889 ssSetDWorkWidth(childS, 3, 1);
40890 ssSetDWorkDataType(childS, 3,SS_INT8);
40891 ssSetDWorkComplexSignal(childS, 3, 0);
40892 ssSetDWorkUsedAsDState(childS, 3, 1);
40893 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 493))[0]);
40894 }
40895
40896 (childS)->regDataType.arg1 = ((void *)(childS));
40897 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
40898 FcnSetErrorStatus);
40899 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
40900 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
40901 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
40902 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
40903
40904 /* registration */
40905#if defined(MATLAB_MEX_FILE)
40906
40907 {
40908 int_T i;
40909 mxArray *plhs[1];
40910 mxArray *prhs[4];
40911 double *pr;
40912 volatile int_T *intS = (int_T *)&childS;
40913 int_T addrlen = sizeof(SimStruct *);
40914 int_T m = addrlen/sizeof(int_T) + 1;
40915 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
40916 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
40917 pr = mxGetPr(prhs[1]);
40918 for (i = 0; i < m - 1; i++) {
40919 pr[i] = (double)intS[i];
40920 }
40921
40922 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
40923 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
40924 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
40925
40926 /* Reset port dimensions info functions because the S-function
40927 * and accelerator mex-files explicitly set their dimensions,
40928 * i.e., they are not dynamically sized. For this case, the
40929 * mex-file is responsible for the dimensions info memory
40930 * and Simulink should not free it. This is achieved by
40931 * setting the following two methods to NULL.
40932 */
40933 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
40934 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
40935
40936 /*
40937 * Setup function pointers and call mdlInitializeSizes via
40938 * simulink.c
40939 */
40940 mexCallMATLAB(1, plhs, 4, prhs, "IntegratorLimited_sf");
40941 mxDestroyArray(plhs[0]);
40942 mxDestroyArray(prhs[0]);
40943 mxDestroyArray(prhs[1]);
40944 mxDestroyArray(prhs[2]);
40945 mxDestroyArray(prhs[3]);
40946 }
40947
40948#else
40949
40950 {
40951 IntegratorLimited_sf(childS);
40952 sfcnInitializeSizes(childS);
40953 }
40954
40955#endif
40956
40957 sfcnInitializeSampleTimes(childS);
40958
40959 /* adjust sample time */
40960 ssSetSampleTime(childS, 0, 0.0);
40961 ssSetOffsetTime(childS, 0, 0.0);
40962 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
40963
40964 /* set compiled values of dynamic vector attributes */
40965 ssSetNumNonsampledZCs(childS, 0);
40966
40967 /* Update connectivity flags for each port */
40968 _ssSetInputPortConnected(childS, 0, 1);
40969 _ssSetInputPortConnected(childS, 1, 1);
40970 _ssSetInputPortConnected(childS, 2, 1);
40971 _ssSetInputPortConnected(childS, 3, 1);
40972 _ssSetInputPortConnected(childS, 4, 1);
40973 _ssSetInputPortConnected(childS, 5, 1);
40974 _ssSetInputPortConnected(childS, 6, 1);
40975 _ssSetOutputPortConnected(childS, 0, 1);
40976 _ssSetOutputPortBeingMerged(childS, 0, 0);
40977
40978 /* Update the BufferDstPort flags for each input port */
40979 _ssSetInputPortBufferDstPort(childS, 0, -1);
40980 _ssSetInputPortBufferDstPort(childS, 1, -1);
40981 _ssSetInputPortBufferDstPort(childS, 2, -1);
40982 _ssSetInputPortBufferDstPort(childS, 3, -1);
40983 _ssSetInputPortBufferDstPort(childS, 4, -1);
40984 _ssSetInputPortBufferDstPort(childS, 5, -1);
40985 _ssSetInputPortBufferDstPort(childS, 6, -1);
40986 }
40987
40988 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S250>/Generated S-Function1 (SaturationLimiter_sf) */
40989 {
40990 SimStruct *childS = ssGetSFunction(rts, 156);
40991
40992 /* timing info */
40993 time_T *sfcnPeriod;
40994 time_T *sfcnOffset;
40995 int_T *sfcnTsMap;
40996 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
40997 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
40998 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
40999 ss_VALIDATE_MEMORY(rts,sfcnOffset);
41000 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
41001 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
41002 (void) memset((void*)sfcnPeriod, 0,
41003 sizeof(time_T)*1);
41004 (void) memset((void*)sfcnOffset, 0,
41005 sizeof(time_T)*1);
41006 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
41007 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
41008 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
41009
41010 /* Set up the mdlInfo pointer */
41011# ifdef USE_RTMODEL
41012
41013 {
41014 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
41015 struct _ssBlkInfo2));
41016 ss_VALIDATE_MEMORY(rts,blkInfo2);
41017 ssSetBlkInfo2Ptr(childS, blkInfo2);
41018 }
41019
41020 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
41021
41022# else
41023
41024 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
41025
41026# endif /* USE_RTMODEL */
41027
41028 /* Allocate memory of model methods 2 */
41029 {
41030 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
41031 malloc(sizeof(struct _ssSFcnModelMethods2));
41032 ss_VALIDATE_MEMORY(rts,methods2);
41033 ssSetModelMethods2(childS, methods2);
41034 }
41035
41036 /* Allocate memory of model methods 3 */
41037 {
41038 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
41039 malloc(sizeof(struct _ssSFcnModelMethods3));
41040 ss_VALIDATE_MEMORY(rts,methods3);
41041 ssSetModelMethods3(childS, methods3);
41042 }
41043
41044 /* Allocate memory for states auxilliary information */
41045 {
41046 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
41047 (sizeof(struct _ssStatesInfo2));
41048 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
41049 malloc(sizeof(ssPeriodicStatesInfo));
41050 ss_VALIDATE_MEMORY(rts,statesInfo2);
41051 ssSetStatesInfo2(childS, statesInfo2);
41052 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
41053 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
41054 }
41055
41056 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
41057 RegNumInputPorts);
41058 ssSetRegNumInputPortsFcnArg(childS,childS);
41059
41060 /* inputs */
41061 {
41062 struct _ssPortInputs *inputPortInfo =
41063 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
41064 ss_VALIDATE_MEMORY(rts,inputPortInfo);
41065 _ssSetNumInputPorts(childS, 3);
41066 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
41067
41068 /* port 0 */
41069 {
41070 real32_T const **sfcnUPtrs = (real32_T const **)
41071 malloc(1 * sizeof(real32_T *));
41072 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41073 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
41074 ssGetLocalBlockIO(rts))->Switch_m;
41075 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
41076 _ssSetInputPortNumDimensions(childS, 0, 1);
41077 ssSetInputPortWidth(childS, 0, 1);
41078 }
41079
41080 /* port 1 */
41081 {
41082 real32_T const **sfcnUPtrs = (real32_T const **)
41083 malloc(1 * sizeof(real32_T *));
41084 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41085 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled130;
41086 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
41087 _ssSetInputPortNumDimensions(childS, 1, 1);
41088 ssSetInputPortWidth(childS, 1, 1);
41089 }
41090
41091 /* port 2 */
41092 {
41093 real32_T const **sfcnUPtrs = (real32_T const **)
41094 malloc(1 * sizeof(real32_T *));
41095 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41096 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled131;
41097 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
41098 _ssSetInputPortNumDimensions(childS, 2, 1);
41099 ssSetInputPortWidth(childS, 2, 1);
41100 }
41101 }
41102
41103 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
41104 RegNumOutputPorts);
41105 ssSetRegNumOutputPortsFcnArg(childS,childS);
41106
41107 /* outputs */
41108 {
41109 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
41110 calloc(1, sizeof(struct _ssPortOutputs));
41111 ss_VALIDATE_MEMORY(rts,outputPortInfo);
41112 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
41113 _ssSetNumOutputPorts(childS, 1);
41114
41115 /* port 0 */
41116 {
41117 _ssSetOutputPortNumDimensions(childS, 0, 1);
41118 ssSetOutputPortWidth(childS, 0, 1);
41119 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
41120 ssGetLocalBlockIO(rts))->GeneratedSFunction1_pc));
41121 }
41122 }
41123
41124 /* path info */
41125 _ssSetModelName(childS, "SaturationLimiter_sf");
41126 _ssSetPath(childS,
41127 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/Saturation Limiter4/Generated S-Function1");
41128 if (ssGetRTModel(rts) == (NULL)) {
41129 _ssSetParentSS(childS, rts);
41130 _ssSetRootSS(childS, ssGetRootSS(rts));
41131 } else {
41132 ssSetRTModel(childS,ssGetRTModel(rts));
41133 _ssSetParentSS(childS, (NULL));
41134 _ssSetRootSS(childS, childS);
41135 }
41136
41137 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
41138 (childS)->regDataType.arg1 = ((void *)(childS));
41139 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
41140 FcnSetErrorStatus);
41141 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
41142 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
41143 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
41144 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
41145
41146 /* registration */
41147#if defined(MATLAB_MEX_FILE)
41148
41149 {
41150 int_T i;
41151 mxArray *plhs[1];
41152 mxArray *prhs[4];
41153 double *pr;
41154 volatile int_T *intS = (int_T *)&childS;
41155 int_T addrlen = sizeof(SimStruct *);
41156 int_T m = addrlen/sizeof(int_T) + 1;
41157 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
41158 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
41159 pr = mxGetPr(prhs[1]);
41160 for (i = 0; i < m - 1; i++) {
41161 pr[i] = (double)intS[i];
41162 }
41163
41164 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
41165 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
41166 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
41167
41168 /* Reset port dimensions info functions because the S-function
41169 * and accelerator mex-files explicitly set their dimensions,
41170 * i.e., they are not dynamically sized. For this case, the
41171 * mex-file is responsible for the dimensions info memory
41172 * and Simulink should not free it. This is achieved by
41173 * setting the following two methods to NULL.
41174 */
41175 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
41176 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
41177
41178 /*
41179 * Setup function pointers and call mdlInitializeSizes via
41180 * simulink.c
41181 */
41182 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
41183 mxDestroyArray(plhs[0]);
41184 mxDestroyArray(prhs[0]);
41185 mxDestroyArray(prhs[1]);
41186 mxDestroyArray(prhs[2]);
41187 mxDestroyArray(prhs[3]);
41188 }
41189
41190#else
41191
41192 {
41193 SaturationLimiter_sf(childS);
41194 sfcnInitializeSizes(childS);
41195 }
41196
41197#endif
41198
41199 sfcnInitializeSampleTimes(childS);
41200
41201 /* adjust sample time */
41202 ssSetSampleTime(childS, 0, 0.0);
41203 ssSetOffsetTime(childS, 0, 0.0);
41204 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
41205
41206 /* set compiled values of dynamic vector attributes */
41207 ssSetNumNonsampledZCs(childS, 0);
41208
41209 /* Update connectivity flags for each port */
41210 _ssSetInputPortConnected(childS, 0, 1);
41211 _ssSetInputPortConnected(childS, 1, 1);
41212 _ssSetInputPortConnected(childS, 2, 1);
41213 _ssSetOutputPortConnected(childS, 0, 1);
41214 _ssSetOutputPortBeingMerged(childS, 0, 0);
41215
41216 /* Update the BufferDstPort flags for each input port */
41217 _ssSetInputPortBufferDstPort(childS, 0, -1);
41218 _ssSetInputPortBufferDstPort(childS, 1, -1);
41219 _ssSetInputPortBufferDstPort(childS, 2, -1);
41220 }
41221
41222 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S249>/Generated S-Function7 (RateLimiter_sf) */
41223 {
41224 SimStruct *childS = ssGetSFunction(rts, 157);
41225
41226 /* timing info */
41227 time_T *sfcnPeriod;
41228 time_T *sfcnOffset;
41229 int_T *sfcnTsMap;
41230 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
41231 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
41232 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
41233 ss_VALIDATE_MEMORY(rts,sfcnOffset);
41234 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
41235 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
41236 (void) memset((void*)sfcnPeriod, 0,
41237 sizeof(time_T)*1);
41238 (void) memset((void*)sfcnOffset, 0,
41239 sizeof(time_T)*1);
41240 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
41241 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
41242 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
41243
41244 /* Set up the mdlInfo pointer */
41245# ifdef USE_RTMODEL
41246
41247 {
41248 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
41249 struct _ssBlkInfo2));
41250 ss_VALIDATE_MEMORY(rts,blkInfo2);
41251 ssSetBlkInfo2Ptr(childS, blkInfo2);
41252 }
41253
41254 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
41255
41256# else
41257
41258 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
41259
41260# endif /* USE_RTMODEL */
41261
41262 /* Allocate memory of model methods 2 */
41263 {
41264 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
41265 malloc(sizeof(struct _ssSFcnModelMethods2));
41266 ss_VALIDATE_MEMORY(rts,methods2);
41267 ssSetModelMethods2(childS, methods2);
41268 }
41269
41270 /* Allocate memory of model methods 3 */
41271 {
41272 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
41273 malloc(sizeof(struct _ssSFcnModelMethods3));
41274 ss_VALIDATE_MEMORY(rts,methods3);
41275 ssSetModelMethods3(childS, methods3);
41276 }
41277
41278 /* Allocate memory for states auxilliary information */
41279 {
41280 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
41281 (sizeof(struct _ssStatesInfo2));
41282 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
41283 malloc(sizeof(ssPeriodicStatesInfo));
41284 ss_VALIDATE_MEMORY(rts,statesInfo2);
41285 ssSetStatesInfo2(childS, statesInfo2);
41286 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
41287 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
41288 }
41289
41290 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
41291 RegNumInputPorts);
41292 ssSetRegNumInputPortsFcnArg(childS,childS);
41293
41294 /* inputs */
41295 {
41296 struct _ssPortInputs *inputPortInfo =
41297 (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));
41298 ss_VALIDATE_MEMORY(rts,inputPortInfo);
41299 _ssSetNumInputPorts(childS, 5);
41300 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
41301
41302 /* port 0 */
41303 {
41304 int8_T const **sfcnUPtrs = (int8_T const **)
41305 malloc(1 * sizeof(int8_T *));
41306 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41307 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
41308 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
41309 _ssSetInputPortNumDimensions(childS, 0, 1);
41310 ssSetInputPortWidth(childS, 0, 1);
41311 }
41312
41313 /* port 1 */
41314 {
41315 real32_T const **sfcnUPtrs = (real32_T const **)
41316 malloc(1 * sizeof(real32_T *));
41317 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41318 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
41319 ssGetLocalBlockIO(rts))->Gain_i;
41320 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
41321 _ssSetInputPortNumDimensions(childS, 1, 1);
41322 ssSetInputPortWidth(childS, 1, 1);
41323 }
41324
41325 /* port 2 */
41326 {
41327 real32_T const **sfcnUPtrs = (real32_T const **)
41328 malloc(1 * sizeof(real32_T *));
41329 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41330 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled125;
41331 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
41332 _ssSetInputPortNumDimensions(childS, 2, 1);
41333 ssSetInputPortWidth(childS, 2, 1);
41334 }
41335
41336 /* port 3 */
41337 {
41338 real32_T const **sfcnUPtrs = (real32_T const **)
41339 malloc(1 * sizeof(real32_T *));
41340 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41341 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
41342 ssGetLocalBlockIO(rts))->dtCAS;
41343 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
41344 _ssSetInputPortNumDimensions(childS, 3, 1);
41345 ssSetInputPortWidth(childS, 3, 1);
41346 }
41347
41348 /* port 4 */
41349 {
41350 real32_T const **sfcnUPtrs = (real32_T const **)
41351 malloc(1 * sizeof(real32_T *));
41352 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41353 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
41354 ssGetLocalBlockIO(rts))->GeneratedSFunction1_pc;
41355 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
41356 _ssSetInputPortNumDimensions(childS, 4, 1);
41357 ssSetInputPortWidth(childS, 4, 1);
41358 }
41359 }
41360
41361 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
41362 RegNumOutputPorts);
41363 ssSetRegNumOutputPortsFcnArg(childS,childS);
41364
41365 /* outputs */
41366 {
41367 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
41368 calloc(2, sizeof(struct _ssPortOutputs));
41369 ss_VALIDATE_MEMORY(rts,outputPortInfo);
41370 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
41371 _ssSetNumOutputPorts(childS, 2);
41372
41373 /* port 0 */
41374 {
41375 _ssSetOutputPortNumDimensions(childS, 0, 1);
41376 ssSetOutputPortWidth(childS, 0, 1);
41377 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
41378 ssGetLocalBlockIO(rts))->daint));
41379 }
41380
41381 /* port 1 */
41382 {
41383 _ssSetOutputPortNumDimensions(childS, 1, 1);
41384 ssSetOutputPortWidth(childS, 1, 1);
41385 _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)
41386 ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2_i2));
41387 }
41388 }
41389
41390 /* path info */
41391 _ssSetModelName(childS, "RateLimiter_sf");
41392 _ssSetPath(childS,
41393 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/lon/Rate Limiter3/Generated S-Function7");
41394 if (ssGetRTModel(rts) == (NULL)) {
41395 _ssSetParentSS(childS, rts);
41396 _ssSetRootSS(childS, ssGetRootSS(rts));
41397 } else {
41398 ssSetRTModel(childS,ssGetRTModel(rts));
41399 _ssSetParentSS(childS, (NULL));
41400 _ssSetRootSS(childS, childS);
41401 }
41402
41403 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
41404
41405 /* work vectors */
41406 {
41407 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
41408 (3 * sizeof(struct _ssDWorkRecord));
41409 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
41410 calloc(3, sizeof(struct _ssDWorkAuxRecord));
41411 ss_VALIDATE_MEMORY(rts,dWorkRecord);
41412 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
41413 ssSetSFcnDWork(childS, dWorkRecord);
41414 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
41415 _ssSetNumDWork(childS, 3);
41416
41417 /* DWORK0 */
41418 ssSetDWorkWidth(childS, 0, 1);
41419 ssSetDWorkDataType(childS, 0,SS_SINGLE);
41420 ssSetDWorkComplexSignal(childS, 0, 0);
41421 ssSetDWorkUsedAsDState(childS, 0, 1);
41422 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 265))[0]);
41423
41424 /* DWORK1 */
41425 ssSetDWorkWidth(childS, 1, 1);
41426 ssSetDWorkDataType(childS, 1,SS_INT8);
41427 ssSetDWorkComplexSignal(childS, 1, 0);
41428 ssSetDWorkUsedAsDState(childS, 1, 1);
41429 _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 494))[0]);
41430
41431 /* DWORK2 */
41432 ssSetDWorkWidth(childS, 2, 1);
41433 ssSetDWorkDataType(childS, 2,SS_INT8);
41434 ssSetDWorkComplexSignal(childS, 2, 0);
41435 ssSetDWorkUsedAsDState(childS, 2, 1);
41436 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 495))[0]);
41437 }
41438
41439 (childS)->regDataType.arg1 = ((void *)(childS));
41440 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
41441 FcnSetErrorStatus);
41442 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
41443 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
41444 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
41445 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
41446
41447 /* registration */
41448#if defined(MATLAB_MEX_FILE)
41449
41450 {
41451 int_T i;
41452 mxArray *plhs[1];
41453 mxArray *prhs[4];
41454 double *pr;
41455 volatile int_T *intS = (int_T *)&childS;
41456 int_T addrlen = sizeof(SimStruct *);
41457 int_T m = addrlen/sizeof(int_T) + 1;
41458 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
41459 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
41460 pr = mxGetPr(prhs[1]);
41461 for (i = 0; i < m - 1; i++) {
41462 pr[i] = (double)intS[i];
41463 }
41464
41465 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
41466 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
41467 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
41468
41469 /* Reset port dimensions info functions because the S-function
41470 * and accelerator mex-files explicitly set their dimensions,
41471 * i.e., they are not dynamically sized. For this case, the
41472 * mex-file is responsible for the dimensions info memory
41473 * and Simulink should not free it. This is achieved by
41474 * setting the following two methods to NULL.
41475 */
41476 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
41477 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
41478
41479 /*
41480 * Setup function pointers and call mdlInitializeSizes via
41481 * simulink.c
41482 */
41483 mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");
41484 mxDestroyArray(plhs[0]);
41485 mxDestroyArray(prhs[0]);
41486 mxDestroyArray(prhs[1]);
41487 mxDestroyArray(prhs[2]);
41488 mxDestroyArray(prhs[3]);
41489 }
41490
41491#else
41492
41493 {
41494 RateLimiter_sf(childS);
41495 sfcnInitializeSizes(childS);
41496 }
41497
41498#endif
41499
41500 sfcnInitializeSampleTimes(childS);
41501
41502 /* adjust sample time */
41503 ssSetSampleTime(childS, 0, 0.0);
41504 ssSetOffsetTime(childS, 0, 0.0);
41505 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
41506
41507 /* set compiled values of dynamic vector attributes */
41508 ssSetNumNonsampledZCs(childS, 0);
41509
41510 /* Update connectivity flags for each port */
41511 _ssSetInputPortConnected(childS, 0, 1);
41512 _ssSetInputPortConnected(childS, 1, 1);
41513 _ssSetInputPortConnected(childS, 2, 1);
41514 _ssSetInputPortConnected(childS, 3, 1);
41515 _ssSetInputPortConnected(childS, 4, 1);
41516 _ssSetOutputPortConnected(childS, 0, 1);
41517 _ssSetOutputPortConnected(childS, 1, 1);
41518 _ssSetOutputPortBeingMerged(childS, 0, 0);
41519 _ssSetOutputPortBeingMerged(childS, 1, 0);
41520
41521 /* Update the BufferDstPort flags for each input port */
41522 _ssSetInputPortBufferDstPort(childS, 0, -1);
41523 _ssSetInputPortBufferDstPort(childS, 1, -1);
41524 _ssSetInputPortBufferDstPort(childS, 2, -1);
41525 _ssSetInputPortBufferDstPort(childS, 3, -1);
41526 _ssSetInputPortBufferDstPort(childS, 4, -1);
41527 }
41528
41529 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S275>/Generated S-Function1 (SaturationLimiter_sf) */
41530 {
41531 SimStruct *childS = ssGetSFunction(rts, 158);
41532
41533 /* timing info */
41534 time_T *sfcnPeriod;
41535 time_T *sfcnOffset;
41536 int_T *sfcnTsMap;
41537 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
41538 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
41539 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
41540 ss_VALIDATE_MEMORY(rts,sfcnOffset);
41541 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
41542 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
41543 (void) memset((void*)sfcnPeriod, 0,
41544 sizeof(time_T)*1);
41545 (void) memset((void*)sfcnOffset, 0,
41546 sizeof(time_T)*1);
41547 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
41548 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
41549 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
41550
41551 /* Set up the mdlInfo pointer */
41552# ifdef USE_RTMODEL
41553
41554 {
41555 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
41556 struct _ssBlkInfo2));
41557 ss_VALIDATE_MEMORY(rts,blkInfo2);
41558 ssSetBlkInfo2Ptr(childS, blkInfo2);
41559 }
41560
41561 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
41562
41563# else
41564
41565 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
41566
41567# endif /* USE_RTMODEL */
41568
41569 /* Allocate memory of model methods 2 */
41570 {
41571 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
41572 malloc(sizeof(struct _ssSFcnModelMethods2));
41573 ss_VALIDATE_MEMORY(rts,methods2);
41574 ssSetModelMethods2(childS, methods2);
41575 }
41576
41577 /* Allocate memory of model methods 3 */
41578 {
41579 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
41580 malloc(sizeof(struct _ssSFcnModelMethods3));
41581 ss_VALIDATE_MEMORY(rts,methods3);
41582 ssSetModelMethods3(childS, methods3);
41583 }
41584
41585 /* Allocate memory for states auxilliary information */
41586 {
41587 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
41588 (sizeof(struct _ssStatesInfo2));
41589 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
41590 malloc(sizeof(ssPeriodicStatesInfo));
41591 ss_VALIDATE_MEMORY(rts,statesInfo2);
41592 ssSetStatesInfo2(childS, statesInfo2);
41593 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
41594 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
41595 }
41596
41597 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
41598 RegNumInputPorts);
41599 ssSetRegNumInputPortsFcnArg(childS,childS);
41600
41601 /* inputs */
41602 {
41603 struct _ssPortInputs *inputPortInfo =
41604 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
41605 ss_VALIDATE_MEMORY(rts,inputPortInfo);
41606 _ssSetNumInputPorts(childS, 3);
41607 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
41608
41609 /* port 0 */
41610 {
41611 real32_T const **sfcnUPtrs = (real32_T const **)
41612 malloc(1 * sizeof(real32_T *));
41613 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41614 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
41615 ssGetLocalBlockIO(rts))->Switch_i;
41616 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
41617 _ssSetInputPortNumDimensions(childS, 0, 1);
41618 ssSetInputPortWidth(childS, 0, 1);
41619 }
41620
41621 /* port 1 */
41622 {
41623 real32_T const **sfcnUPtrs = (real32_T const **)
41624 malloc(1 * sizeof(real32_T *));
41625 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41626 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
41627 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
41628 _ssSetInputPortNumDimensions(childS, 1, 1);
41629 ssSetInputPortWidth(childS, 1, 1);
41630 }
41631
41632 /* port 2 */
41633 {
41634 real32_T const **sfcnUPtrs = (real32_T const **)
41635 malloc(1 * sizeof(real32_T *));
41636 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41637 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
41638 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
41639 _ssSetInputPortNumDimensions(childS, 2, 1);
41640 ssSetInputPortWidth(childS, 2, 1);
41641 }
41642 }
41643
41644 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
41645 RegNumOutputPorts);
41646 ssSetRegNumOutputPortsFcnArg(childS,childS);
41647
41648 /* outputs */
41649 {
41650 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
41651 calloc(1, sizeof(struct _ssPortOutputs));
41652 ss_VALIDATE_MEMORY(rts,outputPortInfo);
41653 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
41654 _ssSetNumOutputPorts(childS, 1);
41655
41656 /* port 0 */
41657 {
41658 _ssSetOutputPortNumDimensions(childS, 0, 1);
41659 ssSetOutputPortWidth(childS, 0, 1);
41660 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
41661 ssGetLocalBlockIO(rts))->GeneratedSFunction1_hf));
41662 }
41663 }
41664
41665 /* path info */
41666 _ssSetModelName(childS, "SaturationLimiter_sf");
41667 _ssSetPath(childS,
41668 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/sb/Saturation Limiter1/Generated S-Function1");
41669 if (ssGetRTModel(rts) == (NULL)) {
41670 _ssSetParentSS(childS, rts);
41671 _ssSetRootSS(childS, ssGetRootSS(rts));
41672 } else {
41673 ssSetRTModel(childS,ssGetRTModel(rts));
41674 _ssSetParentSS(childS, (NULL));
41675 _ssSetRootSS(childS, childS);
41676 }
41677
41678 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
41679 (childS)->regDataType.arg1 = ((void *)(childS));
41680 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
41681 FcnSetErrorStatus);
41682 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
41683 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
41684 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
41685 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
41686
41687 /* registration */
41688#if defined(MATLAB_MEX_FILE)
41689
41690 {
41691 int_T i;
41692 mxArray *plhs[1];
41693 mxArray *prhs[4];
41694 double *pr;
41695 volatile int_T *intS = (int_T *)&childS;
41696 int_T addrlen = sizeof(SimStruct *);
41697 int_T m = addrlen/sizeof(int_T) + 1;
41698 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
41699 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
41700 pr = mxGetPr(prhs[1]);
41701 for (i = 0; i < m - 1; i++) {
41702 pr[i] = (double)intS[i];
41703 }
41704
41705 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
41706 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
41707 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
41708
41709 /* Reset port dimensions info functions because the S-function
41710 * and accelerator mex-files explicitly set their dimensions,
41711 * i.e., they are not dynamically sized. For this case, the
41712 * mex-file is responsible for the dimensions info memory
41713 * and Simulink should not free it. This is achieved by
41714 * setting the following two methods to NULL.
41715 */
41716 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
41717 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
41718
41719 /*
41720 * Setup function pointers and call mdlInitializeSizes via
41721 * simulink.c
41722 */
41723 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
41724 mxDestroyArray(plhs[0]);
41725 mxDestroyArray(prhs[0]);
41726 mxDestroyArray(prhs[1]);
41727 mxDestroyArray(prhs[2]);
41728 mxDestroyArray(prhs[3]);
41729 }
41730
41731#else
41732
41733 {
41734 SaturationLimiter_sf(childS);
41735 sfcnInitializeSizes(childS);
41736 }
41737
41738#endif
41739
41740 sfcnInitializeSampleTimes(childS);
41741
41742 /* adjust sample time */
41743 ssSetSampleTime(childS, 0, 0.0);
41744 ssSetOffsetTime(childS, 0, 0.0);
41745 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
41746
41747 /* set compiled values of dynamic vector attributes */
41748 ssSetNumNonsampledZCs(childS, 0);
41749
41750 /* Update connectivity flags for each port */
41751 _ssSetInputPortConnected(childS, 0, 1);
41752 _ssSetInputPortConnected(childS, 1, 1);
41753 _ssSetInputPortConnected(childS, 2, 1);
41754 _ssSetOutputPortConnected(childS, 0, 1);
41755 _ssSetOutputPortBeingMerged(childS, 0, 0);
41756
41757 /* Update the BufferDstPort flags for each input port */
41758 _ssSetInputPortBufferDstPort(childS, 0, -1);
41759 _ssSetInputPortBufferDstPort(childS, 1, -1);
41760 _ssSetInputPortBufferDstPort(childS, 2, -1);
41761 }
41762
41763 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S274>/Generated S-Function7 (RateLimiter_sf) */
41764 {
41765 SimStruct *childS = ssGetSFunction(rts, 159);
41766
41767 /* timing info */
41768 time_T *sfcnPeriod;
41769 time_T *sfcnOffset;
41770 int_T *sfcnTsMap;
41771 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
41772 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
41773 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
41774 ss_VALIDATE_MEMORY(rts,sfcnOffset);
41775 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
41776 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
41777 (void) memset((void*)sfcnPeriod, 0,
41778 sizeof(time_T)*1);
41779 (void) memset((void*)sfcnOffset, 0,
41780 sizeof(time_T)*1);
41781 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
41782 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
41783 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
41784
41785 /* Set up the mdlInfo pointer */
41786# ifdef USE_RTMODEL
41787
41788 {
41789 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
41790 struct _ssBlkInfo2));
41791 ss_VALIDATE_MEMORY(rts,blkInfo2);
41792 ssSetBlkInfo2Ptr(childS, blkInfo2);
41793 }
41794
41795 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
41796
41797# else
41798
41799 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
41800
41801# endif /* USE_RTMODEL */
41802
41803 /* Allocate memory of model methods 2 */
41804 {
41805 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
41806 malloc(sizeof(struct _ssSFcnModelMethods2));
41807 ss_VALIDATE_MEMORY(rts,methods2);
41808 ssSetModelMethods2(childS, methods2);
41809 }
41810
41811 /* Allocate memory of model methods 3 */
41812 {
41813 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
41814 malloc(sizeof(struct _ssSFcnModelMethods3));
41815 ss_VALIDATE_MEMORY(rts,methods3);
41816 ssSetModelMethods3(childS, methods3);
41817 }
41818
41819 /* Allocate memory for states auxilliary information */
41820 {
41821 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
41822 (sizeof(struct _ssStatesInfo2));
41823 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
41824 malloc(sizeof(ssPeriodicStatesInfo));
41825 ss_VALIDATE_MEMORY(rts,statesInfo2);
41826 ssSetStatesInfo2(childS, statesInfo2);
41827 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
41828 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
41829 }
41830
41831 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
41832 RegNumInputPorts);
41833 ssSetRegNumInputPortsFcnArg(childS,childS);
41834
41835 /* inputs */
41836 {
41837 struct _ssPortInputs *inputPortInfo =
41838 (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));
41839 ss_VALIDATE_MEMORY(rts,inputPortInfo);
41840 _ssSetNumInputPorts(childS, 5);
41841 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
41842
41843 /* port 0 */
41844 {
41845 int8_T const **sfcnUPtrs = (int8_T const **)
41846 malloc(1 * sizeof(int8_T *));
41847 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41848 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
41849 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
41850 _ssSetInputPortNumDimensions(childS, 0, 1);
41851 ssSetInputPortWidth(childS, 0, 1);
41852 }
41853
41854 /* port 1 */
41855 {
41856 real32_T const **sfcnUPtrs = (real32_T const **)
41857 malloc(1 * sizeof(real32_T *));
41858 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41859 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
41860 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
41861 _ssSetInputPortNumDimensions(childS, 1, 1);
41862 ssSetInputPortWidth(childS, 1, 1);
41863 }
41864
41865 /* port 2 */
41866 {
41867 real32_T const **sfcnUPtrs = (real32_T const **)
41868 malloc(1 * sizeof(real32_T *));
41869 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41870 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled133;
41871 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
41872 _ssSetInputPortNumDimensions(childS, 2, 1);
41873 ssSetInputPortWidth(childS, 2, 1);
41874 }
41875
41876 /* port 3 */
41877 {
41878 real32_T const **sfcnUPtrs = (real32_T const **)
41879 malloc(1 * sizeof(real32_T *));
41880 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41881 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
41882 ssGetLocalBlockIO(rts))->dtCAS;
41883 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
41884 _ssSetInputPortNumDimensions(childS, 3, 1);
41885 ssSetInputPortWidth(childS, 3, 1);
41886 }
41887
41888 /* port 4 */
41889 {
41890 real32_T const **sfcnUPtrs = (real32_T const **)
41891 malloc(1 * sizeof(real32_T *));
41892 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
41893 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
41894 ssGetLocalBlockIO(rts))->GeneratedSFunction1_hf;
41895 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
41896 _ssSetInputPortNumDimensions(childS, 4, 1);
41897 ssSetInputPortWidth(childS, 4, 1);
41898 }
41899 }
41900
41901 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
41902 RegNumOutputPorts);
41903 ssSetRegNumOutputPortsFcnArg(childS,childS);
41904
41905 /* outputs */
41906 {
41907 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
41908 calloc(2, sizeof(struct _ssPortOutputs));
41909 ss_VALIDATE_MEMORY(rts,outputPortInfo);
41910 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
41911 _ssSetNumOutputPorts(childS, 2);
41912
41913 /* port 0 */
41914 {
41915 _ssSetOutputPortNumDimensions(childS, 0, 1);
41916 ssSetOutputPortWidth(childS, 0, 1);
41917 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
41918 ssGetLocalBlockIO(rts))->Saturation9));
41919 }
41920
41921 /* port 1 */
41922 {
41923 _ssSetOutputPortNumDimensions(childS, 1, 1);
41924 ssSetOutputPortWidth(childS, 1, 1);
41925 _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)
41926 ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2_f));
41927 }
41928 }
41929
41930 /* path info */
41931 _ssSetModelName(childS, "RateLimiter_sf");
41932 _ssSetPath(childS,
41933 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/sb/Rate Limiter1/Generated S-Function7");
41934 if (ssGetRTModel(rts) == (NULL)) {
41935 _ssSetParentSS(childS, rts);
41936 _ssSetRootSS(childS, ssGetRootSS(rts));
41937 } else {
41938 ssSetRTModel(childS,ssGetRTModel(rts));
41939 _ssSetParentSS(childS, (NULL));
41940 _ssSetRootSS(childS, childS);
41941 }
41942
41943 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
41944
41945 /* work vectors */
41946 {
41947 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
41948 (3 * sizeof(struct _ssDWorkRecord));
41949 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
41950 calloc(3, sizeof(struct _ssDWorkAuxRecord));
41951 ss_VALIDATE_MEMORY(rts,dWorkRecord);
41952 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
41953 ssSetSFcnDWork(childS, dWorkRecord);
41954 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
41955 _ssSetNumDWork(childS, 3);
41956
41957 /* DWORK0 */
41958 ssSetDWorkWidth(childS, 0, 1);
41959 ssSetDWorkDataType(childS, 0,SS_SINGLE);
41960 ssSetDWorkComplexSignal(childS, 0, 0);
41961 ssSetDWorkUsedAsDState(childS, 0, 1);
41962 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 266))[0]);
41963
41964 /* DWORK1 */
41965 ssSetDWorkWidth(childS, 1, 1);
41966 ssSetDWorkDataType(childS, 1,SS_INT8);
41967 ssSetDWorkComplexSignal(childS, 1, 0);
41968 ssSetDWorkUsedAsDState(childS, 1, 1);
41969 _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 496))[0]);
41970
41971 /* DWORK2 */
41972 ssSetDWorkWidth(childS, 2, 1);
41973 ssSetDWorkDataType(childS, 2,SS_INT8);
41974 ssSetDWorkComplexSignal(childS, 2, 0);
41975 ssSetDWorkUsedAsDState(childS, 2, 1);
41976 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 497))[0]);
41977 }
41978
41979 (childS)->regDataType.arg1 = ((void *)(childS));
41980 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
41981 FcnSetErrorStatus);
41982 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
41983 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
41984 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
41985 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
41986
41987 /* registration */
41988#if defined(MATLAB_MEX_FILE)
41989
41990 {
41991 int_T i;
41992 mxArray *plhs[1];
41993 mxArray *prhs[4];
41994 double *pr;
41995 volatile int_T *intS = (int_T *)&childS;
41996 int_T addrlen = sizeof(SimStruct *);
41997 int_T m = addrlen/sizeof(int_T) + 1;
41998 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
41999 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
42000 pr = mxGetPr(prhs[1]);
42001 for (i = 0; i < m - 1; i++) {
42002 pr[i] = (double)intS[i];
42003 }
42004
42005 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
42006 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
42007 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
42008
42009 /* Reset port dimensions info functions because the S-function
42010 * and accelerator mex-files explicitly set their dimensions,
42011 * i.e., they are not dynamically sized. For this case, the
42012 * mex-file is responsible for the dimensions info memory
42013 * and Simulink should not free it. This is achieved by
42014 * setting the following two methods to NULL.
42015 */
42016 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
42017 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
42018
42019 /*
42020 * Setup function pointers and call mdlInitializeSizes via
42021 * simulink.c
42022 */
42023 mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");
42024 mxDestroyArray(plhs[0]);
42025 mxDestroyArray(prhs[0]);
42026 mxDestroyArray(prhs[1]);
42027 mxDestroyArray(prhs[2]);
42028 mxDestroyArray(prhs[3]);
42029 }
42030
42031#else
42032
42033 {
42034 RateLimiter_sf(childS);
42035 sfcnInitializeSizes(childS);
42036 }
42037
42038#endif
42039
42040 sfcnInitializeSampleTimes(childS);
42041
42042 /* adjust sample time */
42043 ssSetSampleTime(childS, 0, 0.0);
42044 ssSetOffsetTime(childS, 0, 0.0);
42045 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
42046
42047 /* set compiled values of dynamic vector attributes */
42048 ssSetNumNonsampledZCs(childS, 0);
42049
42050 /* Update connectivity flags for each port */
42051 _ssSetInputPortConnected(childS, 0, 1);
42052 _ssSetInputPortConnected(childS, 1, 1);
42053 _ssSetInputPortConnected(childS, 2, 1);
42054 _ssSetInputPortConnected(childS, 3, 1);
42055 _ssSetInputPortConnected(childS, 4, 1);
42056 _ssSetOutputPortConnected(childS, 0, 1);
42057 _ssSetOutputPortConnected(childS, 1, 1);
42058 _ssSetOutputPortBeingMerged(childS, 0, 0);
42059 _ssSetOutputPortBeingMerged(childS, 1, 0);
42060
42061 /* Update the BufferDstPort flags for each input port */
42062 _ssSetInputPortBufferDstPort(childS, 0, -1);
42063 _ssSetInputPortBufferDstPort(childS, 1, -1);
42064 _ssSetInputPortBufferDstPort(childS, 2, -1);
42065 _ssSetInputPortBufferDstPort(childS, 3, -1);
42066 _ssSetInputPortBufferDstPort(childS, 4, -1);
42067 }
42068
42069 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S215>/Generated S-Function4 (LagFilter_sf) */
42070 {
42071 SimStruct *childS = ssGetSFunction(rts, 160);
42072
42073 /* timing info */
42074 time_T *sfcnPeriod;
42075 time_T *sfcnOffset;
42076 int_T *sfcnTsMap;
42077 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
42078 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
42079 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
42080 ss_VALIDATE_MEMORY(rts,sfcnOffset);
42081 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
42082 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
42083 (void) memset((void*)sfcnPeriod, 0,
42084 sizeof(time_T)*1);
42085 (void) memset((void*)sfcnOffset, 0,
42086 sizeof(time_T)*1);
42087 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
42088 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
42089 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
42090
42091 /* Set up the mdlInfo pointer */
42092# ifdef USE_RTMODEL
42093
42094 {
42095 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
42096 struct _ssBlkInfo2));
42097 ss_VALIDATE_MEMORY(rts,blkInfo2);
42098 ssSetBlkInfo2Ptr(childS, blkInfo2);
42099 }
42100
42101 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
42102
42103# else
42104
42105 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
42106
42107# endif /* USE_RTMODEL */
42108
42109 /* Allocate memory of model methods 2 */
42110 {
42111 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
42112 malloc(sizeof(struct _ssSFcnModelMethods2));
42113 ss_VALIDATE_MEMORY(rts,methods2);
42114 ssSetModelMethods2(childS, methods2);
42115 }
42116
42117 /* Allocate memory of model methods 3 */
42118 {
42119 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
42120 malloc(sizeof(struct _ssSFcnModelMethods3));
42121 ss_VALIDATE_MEMORY(rts,methods3);
42122 ssSetModelMethods3(childS, methods3);
42123 }
42124
42125 /* Allocate memory for states auxilliary information */
42126 {
42127 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
42128 (sizeof(struct _ssStatesInfo2));
42129 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
42130 malloc(sizeof(ssPeriodicStatesInfo));
42131 ss_VALIDATE_MEMORY(rts,statesInfo2);
42132 ssSetStatesInfo2(childS, statesInfo2);
42133 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
42134 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
42135 }
42136
42137 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
42138 RegNumInputPorts);
42139 ssSetRegNumInputPortsFcnArg(childS,childS);
42140
42141 /* inputs */
42142 {
42143 struct _ssPortInputs *inputPortInfo =
42144 (struct _ssPortInputs *) calloc(6, sizeof(struct _ssPortInputs));
42145 ss_VALIDATE_MEMORY(rts,inputPortInfo);
42146 _ssSetNumInputPorts(childS, 6);
42147 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
42148
42149 /* port 0 */
42150 {
42151 real32_T const **sfcnUPtrs = (real32_T const **)
42152 malloc(1 * sizeof(real32_T *));
42153 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42154 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42155 ssGetLocalBlockIO(rts))->dtCAS;
42156 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
42157 _ssSetInputPortNumDimensions(childS, 0, 1);
42158 ssSetInputPortWidth(childS, 0, 1);
42159 }
42160
42161 /* port 1 */
42162 {
42163 int8_T const **sfcnUPtrs = (int8_T const **)
42164 malloc(1 * sizeof(int8_T *));
42165 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42166 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
42167 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
42168 _ssSetInputPortNumDimensions(childS, 1, 1);
42169 ssSetInputPortWidth(childS, 1, 1);
42170 }
42171
42172 /* port 2 */
42173 {
42174 real32_T const **sfcnUPtrs = (real32_T const **)
42175 malloc(1 * sizeof(real32_T *));
42176 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42177 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled126;
42178 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
42179 _ssSetInputPortNumDimensions(childS, 2, 1);
42180 ssSetInputPortWidth(childS, 2, 1);
42181 }
42182
42183 /* port 3 */
42184 {
42185 real32_T const **sfcnUPtrs = (real32_T const **)
42186 malloc(1 * sizeof(real32_T *));
42187 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42188 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42189 ssGetLocalBlockIO(rts))->Saturation1_o;
42190 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
42191 _ssSetInputPortNumDimensions(childS, 3, 1);
42192 ssSetInputPortWidth(childS, 3, 1);
42193 }
42194
42195 /* port 4 */
42196 {
42197 real32_T const **sfcnUPtrs = (real32_T const **)
42198 malloc(1 * sizeof(real32_T *));
42199 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42200 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42201 ssGetLocalBlockIO(rts))->Saturation1_o;
42202 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
42203 _ssSetInputPortNumDimensions(childS, 4, 1);
42204 ssSetInputPortWidth(childS, 4, 1);
42205 }
42206
42207 /* port 5 */
42208 {
42209 real32_T const **sfcnUPtrs = (real32_T const **)
42210 malloc(1 * sizeof(real32_T *));
42211 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42212 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42213 ssGetLocalBlockIO(rts))->Saturation_p;
42214 _ssSetInputPortSignalPtrs(childS, 5, (InputPtrsType)&sfcnUPtrs[0]);
42215 _ssSetInputPortNumDimensions(childS, 5, 1);
42216 ssSetInputPortWidth(childS, 5, 1);
42217 }
42218 }
42219
42220 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
42221 RegNumOutputPorts);
42222 ssSetRegNumOutputPortsFcnArg(childS,childS);
42223
42224 /* outputs */
42225 {
42226 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
42227 calloc(1, sizeof(struct _ssPortOutputs));
42228 ss_VALIDATE_MEMORY(rts,outputPortInfo);
42229 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
42230 _ssSetNumOutputPorts(childS, 1);
42231
42232 /* port 0 */
42233 {
42234 _ssSetOutputPortNumDimensions(childS, 0, 1);
42235 ssSetOutputPortWidth(childS, 0, 1);
42236 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
42237 ssGetLocalBlockIO(rts))->GeneratedSFunction7_o1));
42238 }
42239 }
42240
42241 /* path info */
42242 _ssSetModelName(childS, "LagFilter_sf");
42243 _ssSetPath(childS,
42244 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/NwsBrk/ lag filter2/Generated S-Function4");
42245 if (ssGetRTModel(rts) == (NULL)) {
42246 _ssSetParentSS(childS, rts);
42247 _ssSetRootSS(childS, ssGetRootSS(rts));
42248 } else {
42249 ssSetRTModel(childS,ssGetRTModel(rts));
42250 _ssSetParentSS(childS, (NULL));
42251 _ssSetRootSS(childS, childS);
42252 }
42253
42254 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
42255
42256 /* work vectors */
42257 {
42258 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
42259 (4 * sizeof(struct _ssDWorkRecord));
42260 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
42261 calloc(4, sizeof(struct _ssDWorkAuxRecord));
42262 ss_VALIDATE_MEMORY(rts,dWorkRecord);
42263 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
42264 ssSetSFcnDWork(childS, dWorkRecord);
42265 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
42266 _ssSetNumDWork(childS, 4);
42267
42268 /* DWORK0 */
42269 ssSetDWorkWidth(childS, 0, 1);
42270 ssSetDWorkDataType(childS, 0,SS_SINGLE);
42271 ssSetDWorkComplexSignal(childS, 0, 0);
42272 ssSetDWorkUsedAsDState(childS, 0, 1);
42273 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 267))[0]);
42274
42275 /* DWORK1 */
42276 ssSetDWorkWidth(childS, 1, 1);
42277 ssSetDWorkDataType(childS, 1,SS_SINGLE);
42278 ssSetDWorkComplexSignal(childS, 1, 0);
42279 ssSetDWorkUsedAsDState(childS, 1, 1);
42280 _ssSetDWork(childS, 1, &((real32_T*) ssGetDWork(rts, 268))[0]);
42281
42282 /* DWORK2 */
42283 ssSetDWorkWidth(childS, 2, 1);
42284 ssSetDWorkDataType(childS, 2,SS_INT8);
42285 ssSetDWorkComplexSignal(childS, 2, 0);
42286 ssSetDWorkUsedAsDState(childS, 2, 1);
42287 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 498))[0]);
42288
42289 /* DWORK3 */
42290 ssSetDWorkWidth(childS, 3, 1);
42291 ssSetDWorkDataType(childS, 3,SS_INT8);
42292 ssSetDWorkComplexSignal(childS, 3, 0);
42293 ssSetDWorkUsedAsDState(childS, 3, 1);
42294 _ssSetDWork(childS, 3, &((int8_T*) ssGetDWork(rts, 499))[0]);
42295 }
42296
42297 (childS)->regDataType.arg1 = ((void *)(childS));
42298 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
42299 FcnSetErrorStatus);
42300 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
42301 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
42302 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
42303 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
42304
42305 /* registration */
42306#if defined(MATLAB_MEX_FILE)
42307
42308 {
42309 int_T i;
42310 mxArray *plhs[1];
42311 mxArray *prhs[4];
42312 double *pr;
42313 volatile int_T *intS = (int_T *)&childS;
42314 int_T addrlen = sizeof(SimStruct *);
42315 int_T m = addrlen/sizeof(int_T) + 1;
42316 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
42317 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
42318 pr = mxGetPr(prhs[1]);
42319 for (i = 0; i < m - 1; i++) {
42320 pr[i] = (double)intS[i];
42321 }
42322
42323 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
42324 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
42325 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
42326
42327 /* Reset port dimensions info functions because the S-function
42328 * and accelerator mex-files explicitly set their dimensions,
42329 * i.e., they are not dynamically sized. For this case, the
42330 * mex-file is responsible for the dimensions info memory
42331 * and Simulink should not free it. This is achieved by
42332 * setting the following two methods to NULL.
42333 */
42334 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
42335 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
42336
42337 /*
42338 * Setup function pointers and call mdlInitializeSizes via
42339 * simulink.c
42340 */
42341 mexCallMATLAB(1, plhs, 4, prhs, "LagFilter_sf");
42342 mxDestroyArray(plhs[0]);
42343 mxDestroyArray(prhs[0]);
42344 mxDestroyArray(prhs[1]);
42345 mxDestroyArray(prhs[2]);
42346 mxDestroyArray(prhs[3]);
42347 }
42348
42349#else
42350
42351 {
42352 LagFilter_sf(childS);
42353 sfcnInitializeSizes(childS);
42354 }
42355
42356#endif
42357
42358 sfcnInitializeSampleTimes(childS);
42359
42360 /* adjust sample time */
42361 ssSetSampleTime(childS, 0, 0.0);
42362 ssSetOffsetTime(childS, 0, 0.0);
42363 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
42364
42365 /* set compiled values of dynamic vector attributes */
42366 ssSetNumNonsampledZCs(childS, 0);
42367
42368 /* Update connectivity flags for each port */
42369 _ssSetInputPortConnected(childS, 0, 1);
42370 _ssSetInputPortConnected(childS, 1, 1);
42371 _ssSetInputPortConnected(childS, 2, 1);
42372 _ssSetInputPortConnected(childS, 3, 1);
42373 _ssSetInputPortConnected(childS, 4, 1);
42374 _ssSetInputPortConnected(childS, 5, 1);
42375 _ssSetOutputPortConnected(childS, 0, 1);
42376 _ssSetOutputPortBeingMerged(childS, 0, 0);
42377
42378 /* Update the BufferDstPort flags for each input port */
42379 _ssSetInputPortBufferDstPort(childS, 0, -1);
42380 _ssSetInputPortBufferDstPort(childS, 1, -1);
42381 _ssSetInputPortBufferDstPort(childS, 2, -1);
42382 _ssSetInputPortBufferDstPort(childS, 3, -1);
42383 _ssSetInputPortBufferDstPort(childS, 4, -1);
42384 _ssSetInputPortBufferDstPort(childS, 5, -1);
42385 }
42386
42387 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S218>/Generated S-Function (Gain_sf) */
42388 {
42389 SimStruct *childS = ssGetSFunction(rts, 161);
42390
42391 /* timing info */
42392 time_T *sfcnPeriod;
42393 time_T *sfcnOffset;
42394 int_T *sfcnTsMap;
42395 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
42396 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
42397 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
42398 ss_VALIDATE_MEMORY(rts,sfcnOffset);
42399 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
42400 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
42401 (void) memset((void*)sfcnPeriod, 0,
42402 sizeof(time_T)*1);
42403 (void) memset((void*)sfcnOffset, 0,
42404 sizeof(time_T)*1);
42405 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
42406 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
42407 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
42408
42409 /* Set up the mdlInfo pointer */
42410# ifdef USE_RTMODEL
42411
42412 {
42413 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
42414 struct _ssBlkInfo2));
42415 ss_VALIDATE_MEMORY(rts,blkInfo2);
42416 ssSetBlkInfo2Ptr(childS, blkInfo2);
42417 }
42418
42419 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
42420
42421# else
42422
42423 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
42424
42425# endif /* USE_RTMODEL */
42426
42427 /* Allocate memory of model methods 2 */
42428 {
42429 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
42430 malloc(sizeof(struct _ssSFcnModelMethods2));
42431 ss_VALIDATE_MEMORY(rts,methods2);
42432 ssSetModelMethods2(childS, methods2);
42433 }
42434
42435 /* Allocate memory of model methods 3 */
42436 {
42437 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
42438 malloc(sizeof(struct _ssSFcnModelMethods3));
42439 ss_VALIDATE_MEMORY(rts,methods3);
42440 ssSetModelMethods3(childS, methods3);
42441 }
42442
42443 /* Allocate memory for states auxilliary information */
42444 {
42445 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
42446 (sizeof(struct _ssStatesInfo2));
42447 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
42448 malloc(sizeof(ssPeriodicStatesInfo));
42449 ss_VALIDATE_MEMORY(rts,statesInfo2);
42450 ssSetStatesInfo2(childS, statesInfo2);
42451 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
42452 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
42453 }
42454
42455 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
42456 RegNumInputPorts);
42457 ssSetRegNumInputPortsFcnArg(childS,childS);
42458
42459 /* inputs */
42460 {
42461 struct _ssPortInputs *inputPortInfo =
42462 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
42463 ss_VALIDATE_MEMORY(rts,inputPortInfo);
42464 _ssSetNumInputPorts(childS, 2);
42465 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
42466
42467 /* port 0 */
42468 {
42469 real32_T const **sfcnUPtrs = (real32_T const **)
42470 malloc(1 * sizeof(real32_T *));
42471 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42472 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42473 ssGetLocalBlockIO(rts))->Sum_b;
42474 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
42475 _ssSetInputPortNumDimensions(childS, 0, 1);
42476 ssSetInputPortWidth(childS, 0, 1);
42477 }
42478
42479 /* port 1 */
42480 {
42481 real32_T const **sfcnUPtrs = (real32_T const **)
42482 malloc(1 * sizeof(real32_T *));
42483 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42484 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled133;
42485 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
42486 _ssSetInputPortNumDimensions(childS, 1, 1);
42487 ssSetInputPortWidth(childS, 1, 1);
42488 }
42489 }
42490
42491 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
42492 RegNumOutputPorts);
42493 ssSetRegNumOutputPortsFcnArg(childS,childS);
42494
42495 /* outputs */
42496 {
42497 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
42498 calloc(1, sizeof(struct _ssPortOutputs));
42499 ss_VALIDATE_MEMORY(rts,outputPortInfo);
42500 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
42501 _ssSetNumOutputPorts(childS, 1);
42502
42503 /* port 0 */
42504 {
42505 _ssSetOutputPortNumDimensions(childS, 0, 1);
42506 ssSetOutputPortWidth(childS, 0, 1);
42507 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
42508 ssGetLocalBlockIO(rts))->GeneratedSFunction_ka));
42509 }
42510 }
42511
42512 /* path info */
42513 _ssSetModelName(childS, "Gain_sf");
42514 _ssSetPath(childS,
42515 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/NwsBrk/gain3/Generated S-Function");
42516 if (ssGetRTModel(rts) == (NULL)) {
42517 _ssSetParentSS(childS, rts);
42518 _ssSetRootSS(childS, ssGetRootSS(rts));
42519 } else {
42520 ssSetRTModel(childS,ssGetRTModel(rts));
42521 _ssSetParentSS(childS, (NULL));
42522 _ssSetRootSS(childS, childS);
42523 }
42524
42525 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
42526 (childS)->regDataType.arg1 = ((void *)(childS));
42527 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
42528 FcnSetErrorStatus);
42529 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
42530 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
42531 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
42532 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
42533
42534 /* registration */
42535#if defined(MATLAB_MEX_FILE)
42536
42537 {
42538 int_T i;
42539 mxArray *plhs[1];
42540 mxArray *prhs[4];
42541 double *pr;
42542 volatile int_T *intS = (int_T *)&childS;
42543 int_T addrlen = sizeof(SimStruct *);
42544 int_T m = addrlen/sizeof(int_T) + 1;
42545 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
42546 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
42547 pr = mxGetPr(prhs[1]);
42548 for (i = 0; i < m - 1; i++) {
42549 pr[i] = (double)intS[i];
42550 }
42551
42552 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
42553 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
42554 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
42555
42556 /* Reset port dimensions info functions because the S-function
42557 * and accelerator mex-files explicitly set their dimensions,
42558 * i.e., they are not dynamically sized. For this case, the
42559 * mex-file is responsible for the dimensions info memory
42560 * and Simulink should not free it. This is achieved by
42561 * setting the following two methods to NULL.
42562 */
42563 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
42564 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
42565
42566 /*
42567 * Setup function pointers and call mdlInitializeSizes via
42568 * simulink.c
42569 */
42570 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
42571 mxDestroyArray(plhs[0]);
42572 mxDestroyArray(prhs[0]);
42573 mxDestroyArray(prhs[1]);
42574 mxDestroyArray(prhs[2]);
42575 mxDestroyArray(prhs[3]);
42576 }
42577
42578#else
42579
42580 {
42581 Gain_sf(childS);
42582 sfcnInitializeSizes(childS);
42583 }
42584
42585#endif
42586
42587 sfcnInitializeSampleTimes(childS);
42588
42589 /* adjust sample time */
42590 ssSetSampleTime(childS, 0, 0.0);
42591 ssSetOffsetTime(childS, 0, 0.0);
42592 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
42593
42594 /* set compiled values of dynamic vector attributes */
42595 ssSetNumNonsampledZCs(childS, 0);
42596
42597 /* Update connectivity flags for each port */
42598 _ssSetInputPortConnected(childS, 0, 1);
42599 _ssSetInputPortConnected(childS, 1, 1);
42600 _ssSetOutputPortConnected(childS, 0, 1);
42601 _ssSetOutputPortBeingMerged(childS, 0, 0);
42602
42603 /* Update the BufferDstPort flags for each input port */
42604 _ssSetInputPortBufferDstPort(childS, 0, -1);
42605 _ssSetInputPortBufferDstPort(childS, 1, -1);
42606 }
42607
42608 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S217>/Generated S-Function1 (SaturationLimiter_sf) */
42609 {
42610 SimStruct *childS = ssGetSFunction(rts, 162);
42611
42612 /* timing info */
42613 time_T *sfcnPeriod;
42614 time_T *sfcnOffset;
42615 int_T *sfcnTsMap;
42616 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
42617 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
42618 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
42619 ss_VALIDATE_MEMORY(rts,sfcnOffset);
42620 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
42621 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
42622 (void) memset((void*)sfcnPeriod, 0,
42623 sizeof(time_T)*1);
42624 (void) memset((void*)sfcnOffset, 0,
42625 sizeof(time_T)*1);
42626 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
42627 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
42628 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
42629
42630 /* Set up the mdlInfo pointer */
42631# ifdef USE_RTMODEL
42632
42633 {
42634 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
42635 struct _ssBlkInfo2));
42636 ss_VALIDATE_MEMORY(rts,blkInfo2);
42637 ssSetBlkInfo2Ptr(childS, blkInfo2);
42638 }
42639
42640 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
42641
42642# else
42643
42644 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
42645
42646# endif /* USE_RTMODEL */
42647
42648 /* Allocate memory of model methods 2 */
42649 {
42650 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
42651 malloc(sizeof(struct _ssSFcnModelMethods2));
42652 ss_VALIDATE_MEMORY(rts,methods2);
42653 ssSetModelMethods2(childS, methods2);
42654 }
42655
42656 /* Allocate memory of model methods 3 */
42657 {
42658 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
42659 malloc(sizeof(struct _ssSFcnModelMethods3));
42660 ss_VALIDATE_MEMORY(rts,methods3);
42661 ssSetModelMethods3(childS, methods3);
42662 }
42663
42664 /* Allocate memory for states auxilliary information */
42665 {
42666 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
42667 (sizeof(struct _ssStatesInfo2));
42668 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
42669 malloc(sizeof(ssPeriodicStatesInfo));
42670 ss_VALIDATE_MEMORY(rts,statesInfo2);
42671 ssSetStatesInfo2(childS, statesInfo2);
42672 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
42673 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
42674 }
42675
42676 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
42677 RegNumInputPorts);
42678 ssSetRegNumInputPortsFcnArg(childS,childS);
42679
42680 /* inputs */
42681 {
42682 struct _ssPortInputs *inputPortInfo =
42683 (struct _ssPortInputs *) calloc(3, sizeof(struct _ssPortInputs));
42684 ss_VALIDATE_MEMORY(rts,inputPortInfo);
42685 _ssSetNumInputPorts(childS, 3);
42686 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
42687
42688 /* port 0 */
42689 {
42690 real32_T const **sfcnUPtrs = (real32_T const **)
42691 malloc(1 * sizeof(real32_T *));
42692 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42693 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42694 ssGetLocalBlockIO(rts))->Switch_bw;
42695 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
42696 _ssSetInputPortNumDimensions(childS, 0, 1);
42697 ssSetInputPortWidth(childS, 0, 1);
42698 }
42699
42700 /* port 1 */
42701 {
42702 real32_T const **sfcnUPtrs = (real32_T const **)
42703 malloc(1 * sizeof(real32_T *));
42704 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42705 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42706 ssGetLocalBlockIO(rts))->Product4_o;
42707 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
42708 _ssSetInputPortNumDimensions(childS, 1, 1);
42709 ssSetInputPortWidth(childS, 1, 1);
42710 }
42711
42712 /* port 2 */
42713 {
42714 real32_T const **sfcnUPtrs = (real32_T const **)
42715 malloc(1 * sizeof(real32_T *));
42716 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42717 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42718 ssGetLocalBlockIO(rts))->Product3_d;
42719 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
42720 _ssSetInputPortNumDimensions(childS, 2, 1);
42721 ssSetInputPortWidth(childS, 2, 1);
42722 }
42723 }
42724
42725 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
42726 RegNumOutputPorts);
42727 ssSetRegNumOutputPortsFcnArg(childS,childS);
42728
42729 /* outputs */
42730 {
42731 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
42732 calloc(1, sizeof(struct _ssPortOutputs));
42733 ss_VALIDATE_MEMORY(rts,outputPortInfo);
42734 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
42735 _ssSetNumOutputPorts(childS, 1);
42736
42737 /* port 0 */
42738 {
42739 _ssSetOutputPortNumDimensions(childS, 0, 1);
42740 ssSetOutputPortWidth(childS, 0, 1);
42741 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
42742 ssGetLocalBlockIO(rts))->GeneratedSFunction1_hx));
42743 }
42744 }
42745
42746 /* path info */
42747 _ssSetModelName(childS, "SaturationLimiter_sf");
42748 _ssSetPath(childS,
42749 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/NwsBrk/Saturation Limiter1/Generated S-Function1");
42750 if (ssGetRTModel(rts) == (NULL)) {
42751 _ssSetParentSS(childS, rts);
42752 _ssSetRootSS(childS, ssGetRootSS(rts));
42753 } else {
42754 ssSetRTModel(childS,ssGetRTModel(rts));
42755 _ssSetParentSS(childS, (NULL));
42756 _ssSetRootSS(childS, childS);
42757 }
42758
42759 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
42760 (childS)->regDataType.arg1 = ((void *)(childS));
42761 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
42762 FcnSetErrorStatus);
42763 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
42764 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
42765 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
42766 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
42767
42768 /* registration */
42769#if defined(MATLAB_MEX_FILE)
42770
42771 {
42772 int_T i;
42773 mxArray *plhs[1];
42774 mxArray *prhs[4];
42775 double *pr;
42776 volatile int_T *intS = (int_T *)&childS;
42777 int_T addrlen = sizeof(SimStruct *);
42778 int_T m = addrlen/sizeof(int_T) + 1;
42779 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
42780 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
42781 pr = mxGetPr(prhs[1]);
42782 for (i = 0; i < m - 1; i++) {
42783 pr[i] = (double)intS[i];
42784 }
42785
42786 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
42787 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
42788 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
42789
42790 /* Reset port dimensions info functions because the S-function
42791 * and accelerator mex-files explicitly set their dimensions,
42792 * i.e., they are not dynamically sized. For this case, the
42793 * mex-file is responsible for the dimensions info memory
42794 * and Simulink should not free it. This is achieved by
42795 * setting the following two methods to NULL.
42796 */
42797 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
42798 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
42799
42800 /*
42801 * Setup function pointers and call mdlInitializeSizes via
42802 * simulink.c
42803 */
42804 mexCallMATLAB(1, plhs, 4, prhs, "SaturationLimiter_sf");
42805 mxDestroyArray(plhs[0]);
42806 mxDestroyArray(prhs[0]);
42807 mxDestroyArray(prhs[1]);
42808 mxDestroyArray(prhs[2]);
42809 mxDestroyArray(prhs[3]);
42810 }
42811
42812#else
42813
42814 {
42815 SaturationLimiter_sf(childS);
42816 sfcnInitializeSizes(childS);
42817 }
42818
42819#endif
42820
42821 sfcnInitializeSampleTimes(childS);
42822
42823 /* adjust sample time */
42824 ssSetSampleTime(childS, 0, 0.0);
42825 ssSetOffsetTime(childS, 0, 0.0);
42826 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
42827
42828 /* set compiled values of dynamic vector attributes */
42829 ssSetNumNonsampledZCs(childS, 0);
42830
42831 /* Update connectivity flags for each port */
42832 _ssSetInputPortConnected(childS, 0, 1);
42833 _ssSetInputPortConnected(childS, 1, 1);
42834 _ssSetInputPortConnected(childS, 2, 1);
42835 _ssSetOutputPortConnected(childS, 0, 1);
42836 _ssSetOutputPortBeingMerged(childS, 0, 0);
42837
42838 /* Update the BufferDstPort flags for each input port */
42839 _ssSetInputPortBufferDstPort(childS, 0, -1);
42840 _ssSetInputPortBufferDstPort(childS, 1, -1);
42841 _ssSetInputPortBufferDstPort(childS, 2, -1);
42842 }
42843
42844 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S216>/Generated S-Function7 (RateLimiter_sf) */
42845 {
42846 SimStruct *childS = ssGetSFunction(rts, 163);
42847
42848 /* timing info */
42849 time_T *sfcnPeriod;
42850 time_T *sfcnOffset;
42851 int_T *sfcnTsMap;
42852 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
42853 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
42854 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
42855 ss_VALIDATE_MEMORY(rts,sfcnOffset);
42856 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
42857 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
42858 (void) memset((void*)sfcnPeriod, 0,
42859 sizeof(time_T)*1);
42860 (void) memset((void*)sfcnOffset, 0,
42861 sizeof(time_T)*1);
42862 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
42863 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
42864 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
42865
42866 /* Set up the mdlInfo pointer */
42867# ifdef USE_RTMODEL
42868
42869 {
42870 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
42871 struct _ssBlkInfo2));
42872 ss_VALIDATE_MEMORY(rts,blkInfo2);
42873 ssSetBlkInfo2Ptr(childS, blkInfo2);
42874 }
42875
42876 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
42877
42878# else
42879
42880 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
42881
42882# endif /* USE_RTMODEL */
42883
42884 /* Allocate memory of model methods 2 */
42885 {
42886 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
42887 malloc(sizeof(struct _ssSFcnModelMethods2));
42888 ss_VALIDATE_MEMORY(rts,methods2);
42889 ssSetModelMethods2(childS, methods2);
42890 }
42891
42892 /* Allocate memory of model methods 3 */
42893 {
42894 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
42895 malloc(sizeof(struct _ssSFcnModelMethods3));
42896 ss_VALIDATE_MEMORY(rts,methods3);
42897 ssSetModelMethods3(childS, methods3);
42898 }
42899
42900 /* Allocate memory for states auxilliary information */
42901 {
42902 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
42903 (sizeof(struct _ssStatesInfo2));
42904 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
42905 malloc(sizeof(ssPeriodicStatesInfo));
42906 ss_VALIDATE_MEMORY(rts,statesInfo2);
42907 ssSetStatesInfo2(childS, statesInfo2);
42908 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
42909 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
42910 }
42911
42912 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
42913 RegNumInputPorts);
42914 ssSetRegNumInputPortsFcnArg(childS,childS);
42915
42916 /* inputs */
42917 {
42918 struct _ssPortInputs *inputPortInfo =
42919 (struct _ssPortInputs *) calloc(5, sizeof(struct _ssPortInputs));
42920 ss_VALIDATE_MEMORY(rts,inputPortInfo);
42921 _ssSetNumInputPorts(childS, 5);
42922 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
42923
42924 /* port 0 */
42925 {
42926 int8_T const **sfcnUPtrs = (int8_T const **)
42927 malloc(1 * sizeof(int8_T *));
42928 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42929 sfcnUPtrs[0] = (int8_T const *) &AFCS_MODEL1_ConstP.pooled143;
42930 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
42931 _ssSetInputPortNumDimensions(childS, 0, 1);
42932 ssSetInputPortWidth(childS, 0, 1);
42933 }
42934
42935 /* port 1 */
42936 {
42937 real32_T const **sfcnUPtrs = (real32_T const **)
42938 malloc(1 * sizeof(real32_T *));
42939 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42940 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled106;
42941 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
42942 _ssSetInputPortNumDimensions(childS, 1, 1);
42943 ssSetInputPortWidth(childS, 1, 1);
42944 }
42945
42946 /* port 2 */
42947 {
42948 real32_T const **sfcnUPtrs = (real32_T const **)
42949 malloc(1 * sizeof(real32_T *));
42950 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42951 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled134;
42952 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
42953 _ssSetInputPortNumDimensions(childS, 2, 1);
42954 ssSetInputPortWidth(childS, 2, 1);
42955 }
42956
42957 /* port 3 */
42958 {
42959 real32_T const **sfcnUPtrs = (real32_T const **)
42960 malloc(1 * sizeof(real32_T *));
42961 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42962 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42963 ssGetLocalBlockIO(rts))->dtCAS;
42964 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
42965 _ssSetInputPortNumDimensions(childS, 3, 1);
42966 ssSetInputPortWidth(childS, 3, 1);
42967 }
42968
42969 /* port 4 */
42970 {
42971 real32_T const **sfcnUPtrs = (real32_T const **)
42972 malloc(1 * sizeof(real32_T *));
42973 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
42974 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
42975 ssGetLocalBlockIO(rts))->GeneratedSFunction1_hx;
42976 _ssSetInputPortSignalPtrs(childS, 4, (InputPtrsType)&sfcnUPtrs[0]);
42977 _ssSetInputPortNumDimensions(childS, 4, 1);
42978 ssSetInputPortWidth(childS, 4, 1);
42979 }
42980 }
42981
42982 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
42983 RegNumOutputPorts);
42984 ssSetRegNumOutputPortsFcnArg(childS,childS);
42985
42986 /* outputs */
42987 {
42988 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
42989 calloc(2, sizeof(struct _ssPortOutputs));
42990 ss_VALIDATE_MEMORY(rts,outputPortInfo);
42991 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
42992 _ssSetNumOutputPorts(childS, 2);
42993
42994 /* port 0 */
42995 {
42996 _ssSetOutputPortNumDimensions(childS, 0, 1);
42997 ssSetOutputPortWidth(childS, 0, 1);
42998 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
42999 ssGetLocalBlockIO(rts))->GeneratedSFunction7_o1));
43000 }
43001
43002 /* port 1 */
43003 {
43004 _ssSetOutputPortNumDimensions(childS, 1, 1);
43005 ssSetOutputPortWidth(childS, 1, 1);
43006 _ssSetOutputPortSignal(childS, 1, ((real32_T *) &((B_AFCS_MODEL1_T *)
43007 ssGetLocalBlockIO(rts))->GeneratedSFunction7_o2_k));
43008 }
43009 }
43010
43011 /* path info */
43012 _ssSetModelName(childS, "RateLimiter_sf");
43013 _ssSetPath(childS,
43014 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/CAS/NwsBrk/Rate Limiter1/Generated S-Function7");
43015 if (ssGetRTModel(rts) == (NULL)) {
43016 _ssSetParentSS(childS, rts);
43017 _ssSetRootSS(childS, ssGetRootSS(rts));
43018 } else {
43019 ssSetRTModel(childS,ssGetRTModel(rts));
43020 _ssSetParentSS(childS, (NULL));
43021 _ssSetRootSS(childS, childS);
43022 }
43023
43024 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
43025
43026 /* work vectors */
43027 {
43028 struct _ssDWorkRecord *dWorkRecord = (struct _ssDWorkRecord *) malloc
43029 (3 * sizeof(struct _ssDWorkRecord));
43030 struct _ssDWorkAuxRecord *dWorkAuxRecord = (struct _ssDWorkAuxRecord *)
43031 calloc(3, sizeof(struct _ssDWorkAuxRecord));
43032 ss_VALIDATE_MEMORY(rts,dWorkRecord);
43033 ss_VALIDATE_MEMORY(rts,dWorkAuxRecord);
43034 ssSetSFcnDWork(childS, dWorkRecord);
43035 ssSetSFcnDWorkAux(childS, dWorkAuxRecord);
43036 _ssSetNumDWork(childS, 3);
43037
43038 /* DWORK0 */
43039 ssSetDWorkWidth(childS, 0, 1);
43040 ssSetDWorkDataType(childS, 0,SS_SINGLE);
43041 ssSetDWorkComplexSignal(childS, 0, 0);
43042 ssSetDWorkUsedAsDState(childS, 0, 1);
43043 _ssSetDWork(childS, 0, &((real32_T*) ssGetDWork(rts, 269))[0]);
43044
43045 /* DWORK1 */
43046 ssSetDWorkWidth(childS, 1, 1);
43047 ssSetDWorkDataType(childS, 1,SS_INT8);
43048 ssSetDWorkComplexSignal(childS, 1, 0);
43049 ssSetDWorkUsedAsDState(childS, 1, 1);
43050 _ssSetDWork(childS, 1, &((int8_T*) ssGetDWork(rts, 500))[0]);
43051
43052 /* DWORK2 */
43053 ssSetDWorkWidth(childS, 2, 1);
43054 ssSetDWorkDataType(childS, 2,SS_INT8);
43055 ssSetDWorkComplexSignal(childS, 2, 0);
43056 ssSetDWorkUsedAsDState(childS, 2, 1);
43057 _ssSetDWork(childS, 2, &((int8_T*) ssGetDWork(rts, 501))[0]);
43058 }
43059
43060 (childS)->regDataType.arg1 = ((void *)(childS));
43061 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
43062 FcnSetErrorStatus);
43063 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
43064 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
43065 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
43066 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
43067
43068 /* registration */
43069#if defined(MATLAB_MEX_FILE)
43070
43071 {
43072 int_T i;
43073 mxArray *plhs[1];
43074 mxArray *prhs[4];
43075 double *pr;
43076 volatile int_T *intS = (int_T *)&childS;
43077 int_T addrlen = sizeof(SimStruct *);
43078 int_T m = addrlen/sizeof(int_T) + 1;
43079 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
43080 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
43081 pr = mxGetPr(prhs[1]);
43082 for (i = 0; i < m - 1; i++) {
43083 pr[i] = (double)intS[i];
43084 }
43085
43086 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
43087 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
43088 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
43089
43090 /* Reset port dimensions info functions because the S-function
43091 * and accelerator mex-files explicitly set their dimensions,
43092 * i.e., they are not dynamically sized. For this case, the
43093 * mex-file is responsible for the dimensions info memory
43094 * and Simulink should not free it. This is achieved by
43095 * setting the following two methods to NULL.
43096 */
43097 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
43098 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
43099
43100 /*
43101 * Setup function pointers and call mdlInitializeSizes via
43102 * simulink.c
43103 */
43104 mexCallMATLAB(1, plhs, 4, prhs, "RateLimiter_sf");
43105 mxDestroyArray(plhs[0]);
43106 mxDestroyArray(prhs[0]);
43107 mxDestroyArray(prhs[1]);
43108 mxDestroyArray(prhs[2]);
43109 mxDestroyArray(prhs[3]);
43110 }
43111
43112#else
43113
43114 {
43115 RateLimiter_sf(childS);
43116 sfcnInitializeSizes(childS);
43117 }
43118
43119#endif
43120
43121 sfcnInitializeSampleTimes(childS);
43122
43123 /* adjust sample time */
43124 ssSetSampleTime(childS, 0, 0.0);
43125 ssSetOffsetTime(childS, 0, 0.0);
43126 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
43127
43128 /* set compiled values of dynamic vector attributes */
43129 ssSetNumNonsampledZCs(childS, 0);
43130
43131 /* Update connectivity flags for each port */
43132 _ssSetInputPortConnected(childS, 0, 1);
43133 _ssSetInputPortConnected(childS, 1, 1);
43134 _ssSetInputPortConnected(childS, 2, 1);
43135 _ssSetInputPortConnected(childS, 3, 1);
43136 _ssSetInputPortConnected(childS, 4, 1);
43137 _ssSetOutputPortConnected(childS, 0, 1);
43138 _ssSetOutputPortConnected(childS, 1, 1);
43139 _ssSetOutputPortBeingMerged(childS, 0, 0);
43140 _ssSetOutputPortBeingMerged(childS, 1, 0);
43141
43142 /* Update the BufferDstPort flags for each input port */
43143 _ssSetInputPortBufferDstPort(childS, 0, -1);
43144 _ssSetInputPortBufferDstPort(childS, 1, -1);
43145 _ssSetInputPortBufferDstPort(childS, 2, -1);
43146 _ssSetInputPortBufferDstPort(childS, 3, -1);
43147 _ssSetInputPortBufferDstPort(childS, 4, -1);
43148 }
43149
43150 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S279>/Generated S-Function (Gain_sf) */
43151 {
43152 SimStruct *childS = ssGetSFunction(rts, 164);
43153
43154 /* timing info */
43155 time_T *sfcnPeriod;
43156 time_T *sfcnOffset;
43157 int_T *sfcnTsMap;
43158 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
43159 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
43160 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
43161 ss_VALIDATE_MEMORY(rts,sfcnOffset);
43162 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
43163 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
43164 (void) memset((void*)sfcnPeriod, 0,
43165 sizeof(time_T)*1);
43166 (void) memset((void*)sfcnOffset, 0,
43167 sizeof(time_T)*1);
43168 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
43169 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
43170 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
43171
43172 /* Set up the mdlInfo pointer */
43173# ifdef USE_RTMODEL
43174
43175 {
43176 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
43177 struct _ssBlkInfo2));
43178 ss_VALIDATE_MEMORY(rts,blkInfo2);
43179 ssSetBlkInfo2Ptr(childS, blkInfo2);
43180 }
43181
43182 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
43183
43184# else
43185
43186 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
43187
43188# endif /* USE_RTMODEL */
43189
43190 /* Allocate memory of model methods 2 */
43191 {
43192 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
43193 malloc(sizeof(struct _ssSFcnModelMethods2));
43194 ss_VALIDATE_MEMORY(rts,methods2);
43195 ssSetModelMethods2(childS, methods2);
43196 }
43197
43198 /* Allocate memory of model methods 3 */
43199 {
43200 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
43201 malloc(sizeof(struct _ssSFcnModelMethods3));
43202 ss_VALIDATE_MEMORY(rts,methods3);
43203 ssSetModelMethods3(childS, methods3);
43204 }
43205
43206 /* Allocate memory for states auxilliary information */
43207 {
43208 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
43209 (sizeof(struct _ssStatesInfo2));
43210 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
43211 malloc(sizeof(ssPeriodicStatesInfo));
43212 ss_VALIDATE_MEMORY(rts,statesInfo2);
43213 ssSetStatesInfo2(childS, statesInfo2);
43214 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
43215 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
43216 }
43217
43218 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
43219 RegNumInputPorts);
43220 ssSetRegNumInputPortsFcnArg(childS,childS);
43221
43222 /* inputs */
43223 {
43224 struct _ssPortInputs *inputPortInfo =
43225 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
43226 ss_VALIDATE_MEMORY(rts,inputPortInfo);
43227 _ssSetNumInputPorts(childS, 2);
43228 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
43229
43230 /* port 0 */
43231 {
43232 real32_T const **sfcnUPtrs = (real32_T const **)
43233 malloc(1 * sizeof(real32_T *));
43234 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43235 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
43236 ssGetLocalBlockIO(rts))->Sum1_o;
43237 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
43238 _ssSetInputPortNumDimensions(childS, 0, 1);
43239 ssSetInputPortWidth(childS, 0, 1);
43240 }
43241
43242 /* port 1 */
43243 {
43244 real32_T const **sfcnUPtrs = (real32_T const **)
43245 malloc(1 * sizeof(real32_T *));
43246 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43247 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
43248 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
43249 _ssSetInputPortNumDimensions(childS, 1, 1);
43250 ssSetInputPortWidth(childS, 1, 1);
43251 }
43252 }
43253
43254 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
43255 RegNumOutputPorts);
43256 ssSetRegNumOutputPortsFcnArg(childS,childS);
43257
43258 /* outputs */
43259 {
43260 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
43261 calloc(1, sizeof(struct _ssPortOutputs));
43262 ss_VALIDATE_MEMORY(rts,outputPortInfo);
43263 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
43264 _ssSetNumOutputPorts(childS, 1);
43265
43266 /* port 0 */
43267 {
43268 _ssSetOutputPortNumDimensions(childS, 0, 1);
43269 ssSetOutputPortWidth(childS, 0, 1);
43270 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
43271 ssGetLocalBlockIO(rts))->GeneratedSFunction_gq4));
43272 }
43273 }
43274
43275 /* path info */
43276 _ssSetModelName(childS, "Gain_sf");
43277 _ssSetPath(childS,
43278 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/GNCinit1/apinit/lon/gain/Generated S-Function");
43279 if (ssGetRTModel(rts) == (NULL)) {
43280 _ssSetParentSS(childS, rts);
43281 _ssSetRootSS(childS, ssGetRootSS(rts));
43282 } else {
43283 ssSetRTModel(childS,ssGetRTModel(rts));
43284 _ssSetParentSS(childS, (NULL));
43285 _ssSetRootSS(childS, childS);
43286 }
43287
43288 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
43289 (childS)->regDataType.arg1 = ((void *)(childS));
43290 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
43291 FcnSetErrorStatus);
43292 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
43293 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
43294 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
43295 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
43296
43297 /* registration */
43298#if defined(MATLAB_MEX_FILE)
43299
43300 {
43301 int_T i;
43302 mxArray *plhs[1];
43303 mxArray *prhs[4];
43304 double *pr;
43305 volatile int_T *intS = (int_T *)&childS;
43306 int_T addrlen = sizeof(SimStruct *);
43307 int_T m = addrlen/sizeof(int_T) + 1;
43308 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
43309 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
43310 pr = mxGetPr(prhs[1]);
43311 for (i = 0; i < m - 1; i++) {
43312 pr[i] = (double)intS[i];
43313 }
43314
43315 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
43316 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
43317 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
43318
43319 /* Reset port dimensions info functions because the S-function
43320 * and accelerator mex-files explicitly set their dimensions,
43321 * i.e., they are not dynamically sized. For this case, the
43322 * mex-file is responsible for the dimensions info memory
43323 * and Simulink should not free it. This is achieved by
43324 * setting the following two methods to NULL.
43325 */
43326 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
43327 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
43328
43329 /*
43330 * Setup function pointers and call mdlInitializeSizes via
43331 * simulink.c
43332 */
43333 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
43334 mxDestroyArray(plhs[0]);
43335 mxDestroyArray(prhs[0]);
43336 mxDestroyArray(prhs[1]);
43337 mxDestroyArray(prhs[2]);
43338 mxDestroyArray(prhs[3]);
43339 }
43340
43341#else
43342
43343 {
43344 Gain_sf(childS);
43345 sfcnInitializeSizes(childS);
43346 }
43347
43348#endif
43349
43350 sfcnInitializeSampleTimes(childS);
43351
43352 /* adjust sample time */
43353 ssSetSampleTime(childS, 0, 0.0);
43354 ssSetOffsetTime(childS, 0, 0.0);
43355 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
43356
43357 /* set compiled values of dynamic vector attributes */
43358 ssSetNumNonsampledZCs(childS, 0);
43359
43360 /* Update connectivity flags for each port */
43361 _ssSetInputPortConnected(childS, 0, 1);
43362 _ssSetInputPortConnected(childS, 1, 1);
43363 _ssSetOutputPortConnected(childS, 0, 1);
43364 _ssSetOutputPortBeingMerged(childS, 0, 0);
43365
43366 /* Update the BufferDstPort flags for each input port */
43367 _ssSetInputPortBufferDstPort(childS, 0, -1);
43368 _ssSetInputPortBufferDstPort(childS, 1, -1);
43369 }
43370
43371 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S280>/Generated S-Function (Gain_sf) */
43372 {
43373 SimStruct *childS = ssGetSFunction(rts, 165);
43374
43375 /* timing info */
43376 time_T *sfcnPeriod;
43377 time_T *sfcnOffset;
43378 int_T *sfcnTsMap;
43379 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
43380 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
43381 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
43382 ss_VALIDATE_MEMORY(rts,sfcnOffset);
43383 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
43384 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
43385 (void) memset((void*)sfcnPeriod, 0,
43386 sizeof(time_T)*1);
43387 (void) memset((void*)sfcnOffset, 0,
43388 sizeof(time_T)*1);
43389 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
43390 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
43391 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
43392
43393 /* Set up the mdlInfo pointer */
43394# ifdef USE_RTMODEL
43395
43396 {
43397 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
43398 struct _ssBlkInfo2));
43399 ss_VALIDATE_MEMORY(rts,blkInfo2);
43400 ssSetBlkInfo2Ptr(childS, blkInfo2);
43401 }
43402
43403 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
43404
43405# else
43406
43407 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
43408
43409# endif /* USE_RTMODEL */
43410
43411 /* Allocate memory of model methods 2 */
43412 {
43413 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
43414 malloc(sizeof(struct _ssSFcnModelMethods2));
43415 ss_VALIDATE_MEMORY(rts,methods2);
43416 ssSetModelMethods2(childS, methods2);
43417 }
43418
43419 /* Allocate memory of model methods 3 */
43420 {
43421 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
43422 malloc(sizeof(struct _ssSFcnModelMethods3));
43423 ss_VALIDATE_MEMORY(rts,methods3);
43424 ssSetModelMethods3(childS, methods3);
43425 }
43426
43427 /* Allocate memory for states auxilliary information */
43428 {
43429 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
43430 (sizeof(struct _ssStatesInfo2));
43431 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
43432 malloc(sizeof(ssPeriodicStatesInfo));
43433 ss_VALIDATE_MEMORY(rts,statesInfo2);
43434 ssSetStatesInfo2(childS, statesInfo2);
43435 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
43436 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
43437 }
43438
43439 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
43440 RegNumInputPorts);
43441 ssSetRegNumInputPortsFcnArg(childS,childS);
43442
43443 /* inputs */
43444 {
43445 struct _ssPortInputs *inputPortInfo =
43446 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
43447 ss_VALIDATE_MEMORY(rts,inputPortInfo);
43448 _ssSetNumInputPorts(childS, 2);
43449 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
43450
43451 /* port 0 */
43452 {
43453 real32_T const **sfcnUPtrs = (real32_T const **)
43454 malloc(1 * sizeof(real32_T *));
43455 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43456 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
43457 ssGetLocalBlockIO(rts))->Saturation_bq;
43458 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
43459 _ssSetInputPortNumDimensions(childS, 0, 1);
43460 ssSetInputPortWidth(childS, 0, 1);
43461 }
43462
43463 /* port 1 */
43464 {
43465 real32_T const **sfcnUPtrs = (real32_T const **)
43466 malloc(1 * sizeof(real32_T *));
43467 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43468 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled123;
43469 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
43470 _ssSetInputPortNumDimensions(childS, 1, 1);
43471 ssSetInputPortWidth(childS, 1, 1);
43472 }
43473 }
43474
43475 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
43476 RegNumOutputPorts);
43477 ssSetRegNumOutputPortsFcnArg(childS,childS);
43478
43479 /* outputs */
43480 {
43481 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
43482 calloc(1, sizeof(struct _ssPortOutputs));
43483 ss_VALIDATE_MEMORY(rts,outputPortInfo);
43484 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
43485 _ssSetNumOutputPorts(childS, 1);
43486
43487 /* port 0 */
43488 {
43489 _ssSetOutputPortNumDimensions(childS, 0, 1);
43490 ssSetOutputPortWidth(childS, 0, 1);
43491 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
43492 ssGetLocalBlockIO(rts))->GeneratedSFunction_dw));
43493 }
43494 }
43495
43496 /* path info */
43497 _ssSetModelName(childS, "Gain_sf");
43498 _ssSetPath(childS,
43499 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/GNCinit1/apinit/lon/gain1/Generated S-Function");
43500 if (ssGetRTModel(rts) == (NULL)) {
43501 _ssSetParentSS(childS, rts);
43502 _ssSetRootSS(childS, ssGetRootSS(rts));
43503 } else {
43504 ssSetRTModel(childS,ssGetRTModel(rts));
43505 _ssSetParentSS(childS, (NULL));
43506 _ssSetRootSS(childS, childS);
43507 }
43508
43509 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
43510 (childS)->regDataType.arg1 = ((void *)(childS));
43511 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
43512 FcnSetErrorStatus);
43513 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
43514 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
43515 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
43516 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
43517
43518 /* registration */
43519#if defined(MATLAB_MEX_FILE)
43520
43521 {
43522 int_T i;
43523 mxArray *plhs[1];
43524 mxArray *prhs[4];
43525 double *pr;
43526 volatile int_T *intS = (int_T *)&childS;
43527 int_T addrlen = sizeof(SimStruct *);
43528 int_T m = addrlen/sizeof(int_T) + 1;
43529 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
43530 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
43531 pr = mxGetPr(prhs[1]);
43532 for (i = 0; i < m - 1; i++) {
43533 pr[i] = (double)intS[i];
43534 }
43535
43536 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
43537 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
43538 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
43539
43540 /* Reset port dimensions info functions because the S-function
43541 * and accelerator mex-files explicitly set their dimensions,
43542 * i.e., they are not dynamically sized. For this case, the
43543 * mex-file is responsible for the dimensions info memory
43544 * and Simulink should not free it. This is achieved by
43545 * setting the following two methods to NULL.
43546 */
43547 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
43548 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
43549
43550 /*
43551 * Setup function pointers and call mdlInitializeSizes via
43552 * simulink.c
43553 */
43554 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
43555 mxDestroyArray(plhs[0]);
43556 mxDestroyArray(prhs[0]);
43557 mxDestroyArray(prhs[1]);
43558 mxDestroyArray(prhs[2]);
43559 mxDestroyArray(prhs[3]);
43560 }
43561
43562#else
43563
43564 {
43565 Gain_sf(childS);
43566 sfcnInitializeSizes(childS);
43567 }
43568
43569#endif
43570
43571 sfcnInitializeSampleTimes(childS);
43572
43573 /* adjust sample time */
43574 ssSetSampleTime(childS, 0, 0.0);
43575 ssSetOffsetTime(childS, 0, 0.0);
43576 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
43577
43578 /* set compiled values of dynamic vector attributes */
43579 ssSetNumNonsampledZCs(childS, 0);
43580
43581 /* Update connectivity flags for each port */
43582 _ssSetInputPortConnected(childS, 0, 1);
43583 _ssSetInputPortConnected(childS, 1, 1);
43584 _ssSetOutputPortConnected(childS, 0, 1);
43585 _ssSetOutputPortBeingMerged(childS, 0, 0);
43586
43587 /* Update the BufferDstPort flags for each input port */
43588 _ssSetInputPortBufferDstPort(childS, 0, -1);
43589 _ssSetInputPortBufferDstPort(childS, 1, -1);
43590 }
43591
43592 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S281>/Generated S-Function (Gain_sf) */
43593 {
43594 SimStruct *childS = ssGetSFunction(rts, 166);
43595
43596 /* timing info */
43597 time_T *sfcnPeriod;
43598 time_T *sfcnOffset;
43599 int_T *sfcnTsMap;
43600 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
43601 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
43602 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
43603 ss_VALIDATE_MEMORY(rts,sfcnOffset);
43604 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
43605 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
43606 (void) memset((void*)sfcnPeriod, 0,
43607 sizeof(time_T)*1);
43608 (void) memset((void*)sfcnOffset, 0,
43609 sizeof(time_T)*1);
43610 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
43611 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
43612 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
43613
43614 /* Set up the mdlInfo pointer */
43615# ifdef USE_RTMODEL
43616
43617 {
43618 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
43619 struct _ssBlkInfo2));
43620 ss_VALIDATE_MEMORY(rts,blkInfo2);
43621 ssSetBlkInfo2Ptr(childS, blkInfo2);
43622 }
43623
43624 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
43625
43626# else
43627
43628 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
43629
43630# endif /* USE_RTMODEL */
43631
43632 /* Allocate memory of model methods 2 */
43633 {
43634 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
43635 malloc(sizeof(struct _ssSFcnModelMethods2));
43636 ss_VALIDATE_MEMORY(rts,methods2);
43637 ssSetModelMethods2(childS, methods2);
43638 }
43639
43640 /* Allocate memory of model methods 3 */
43641 {
43642 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
43643 malloc(sizeof(struct _ssSFcnModelMethods3));
43644 ss_VALIDATE_MEMORY(rts,methods3);
43645 ssSetModelMethods3(childS, methods3);
43646 }
43647
43648 /* Allocate memory for states auxilliary information */
43649 {
43650 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
43651 (sizeof(struct _ssStatesInfo2));
43652 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
43653 malloc(sizeof(ssPeriodicStatesInfo));
43654 ss_VALIDATE_MEMORY(rts,statesInfo2);
43655 ssSetStatesInfo2(childS, statesInfo2);
43656 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
43657 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
43658 }
43659
43660 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
43661 RegNumInputPorts);
43662 ssSetRegNumInputPortsFcnArg(childS,childS);
43663
43664 /* inputs */
43665 {
43666 struct _ssPortInputs *inputPortInfo =
43667 (struct _ssPortInputs *) calloc(2, sizeof(struct _ssPortInputs));
43668 ss_VALIDATE_MEMORY(rts,inputPortInfo);
43669 _ssSetNumInputPorts(childS, 2);
43670 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
43671
43672 /* port 0 */
43673 {
43674 real32_T const **sfcnUPtrs = (real32_T const **)
43675 malloc(1 * sizeof(real32_T *));
43676 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43677 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
43678 ssGetLocalBlockIO(rts))->Saturation_bq;
43679 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
43680 _ssSetInputPortNumDimensions(childS, 0, 1);
43681 ssSetInputPortWidth(childS, 0, 1);
43682 }
43683
43684 /* port 1 */
43685 {
43686 real32_T const **sfcnUPtrs = (real32_T const **)
43687 malloc(1 * sizeof(real32_T *));
43688 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43689 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled105;
43690 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
43691 _ssSetInputPortNumDimensions(childS, 1, 1);
43692 ssSetInputPortWidth(childS, 1, 1);
43693 }
43694 }
43695
43696 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
43697 RegNumOutputPorts);
43698 ssSetRegNumOutputPortsFcnArg(childS,childS);
43699
43700 /* outputs */
43701 {
43702 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
43703 calloc(1, sizeof(struct _ssPortOutputs));
43704 ss_VALIDATE_MEMORY(rts,outputPortInfo);
43705 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
43706 _ssSetNumOutputPorts(childS, 1);
43707
43708 /* port 0 */
43709 {
43710 _ssSetOutputPortNumDimensions(childS, 0, 1);
43711 ssSetOutputPortWidth(childS, 0, 1);
43712 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
43713 ssGetLocalBlockIO(rts))->GeneratedSFunction_d4));
43714 }
43715 }
43716
43717 /* path info */
43718 _ssSetModelName(childS, "Gain_sf");
43719 _ssSetPath(childS,
43720 "AFCS_MODEL1/AFCS_MODEL1/GNC/Level/CodeReuseSubsystem/GNCinit1/apinit/lon/gain2/Generated S-Function");
43721 if (ssGetRTModel(rts) == (NULL)) {
43722 _ssSetParentSS(childS, rts);
43723 _ssSetRootSS(childS, ssGetRootSS(rts));
43724 } else {
43725 ssSetRTModel(childS,ssGetRTModel(rts));
43726 _ssSetParentSS(childS, (NULL));
43727 _ssSetRootSS(childS, childS);
43728 }
43729
43730 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
43731 (childS)->regDataType.arg1 = ((void *)(childS));
43732 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
43733 FcnSetErrorStatus);
43734 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
43735 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
43736 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
43737 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
43738
43739 /* registration */
43740#if defined(MATLAB_MEX_FILE)
43741
43742 {
43743 int_T i;
43744 mxArray *plhs[1];
43745 mxArray *prhs[4];
43746 double *pr;
43747 volatile int_T *intS = (int_T *)&childS;
43748 int_T addrlen = sizeof(SimStruct *);
43749 int_T m = addrlen/sizeof(int_T) + 1;
43750 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
43751 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
43752 pr = mxGetPr(prhs[1]);
43753 for (i = 0; i < m - 1; i++) {
43754 pr[i] = (double)intS[i];
43755 }
43756
43757 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
43758 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
43759 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
43760
43761 /* Reset port dimensions info functions because the S-function
43762 * and accelerator mex-files explicitly set their dimensions,
43763 * i.e., they are not dynamically sized. For this case, the
43764 * mex-file is responsible for the dimensions info memory
43765 * and Simulink should not free it. This is achieved by
43766 * setting the following two methods to NULL.
43767 */
43768 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
43769 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
43770
43771 /*
43772 * Setup function pointers and call mdlInitializeSizes via
43773 * simulink.c
43774 */
43775 mexCallMATLAB(1, plhs, 4, prhs, "Gain_sf");
43776 mxDestroyArray(plhs[0]);
43777 mxDestroyArray(prhs[0]);
43778 mxDestroyArray(prhs[1]);
43779 mxDestroyArray(prhs[2]);
43780 mxDestroyArray(prhs[3]);
43781 }
43782
43783#else
43784
43785 {
43786 Gain_sf(childS);
43787 sfcnInitializeSizes(childS);
43788 }
43789
43790#endif
43791
43792 sfcnInitializeSampleTimes(childS);
43793
43794 /* adjust sample time */
43795 ssSetSampleTime(childS, 0, 0.0);
43796 ssSetOffsetTime(childS, 0, 0.0);
43797 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
43798
43799 /* set compiled values of dynamic vector attributes */
43800 ssSetNumNonsampledZCs(childS, 0);
43801
43802 /* Update connectivity flags for each port */
43803 _ssSetInputPortConnected(childS, 0, 1);
43804 _ssSetInputPortConnected(childS, 1, 1);
43805 _ssSetOutputPortConnected(childS, 0, 1);
43806 _ssSetOutputPortBeingMerged(childS, 0, 0);
43807
43808 /* Update the BufferDstPort flags for each input port */
43809 _ssSetInputPortBufferDstPort(childS, 0, -1);
43810 _ssSetInputPortBufferDstPort(childS, 1, -1);
43811 }
43812
43813 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S306>/Generated S-Function15 (StickGradientDeadZone_sf) */
43814 {
43815 SimStruct *childS = ssGetSFunction(rts, 167);
43816
43817 /* timing info */
43818 time_T *sfcnPeriod;
43819 time_T *sfcnOffset;
43820 int_T *sfcnTsMap;
43821 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
43822 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
43823 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
43824 ss_VALIDATE_MEMORY(rts,sfcnOffset);
43825 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
43826 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
43827 (void) memset((void*)sfcnPeriod, 0,
43828 sizeof(time_T)*1);
43829 (void) memset((void*)sfcnOffset, 0,
43830 sizeof(time_T)*1);
43831 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
43832 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
43833 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
43834
43835 /* Set up the mdlInfo pointer */
43836# ifdef USE_RTMODEL
43837
43838 {
43839 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
43840 struct _ssBlkInfo2));
43841 ss_VALIDATE_MEMORY(rts,blkInfo2);
43842 ssSetBlkInfo2Ptr(childS, blkInfo2);
43843 }
43844
43845 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
43846
43847# else
43848
43849 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
43850
43851# endif /* USE_RTMODEL */
43852
43853 /* Allocate memory of model methods 2 */
43854 {
43855 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
43856 malloc(sizeof(struct _ssSFcnModelMethods2));
43857 ss_VALIDATE_MEMORY(rts,methods2);
43858 ssSetModelMethods2(childS, methods2);
43859 }
43860
43861 /* Allocate memory of model methods 3 */
43862 {
43863 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
43864 malloc(sizeof(struct _ssSFcnModelMethods3));
43865 ss_VALIDATE_MEMORY(rts,methods3);
43866 ssSetModelMethods3(childS, methods3);
43867 }
43868
43869 /* Allocate memory for states auxilliary information */
43870 {
43871 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
43872 (sizeof(struct _ssStatesInfo2));
43873 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
43874 malloc(sizeof(ssPeriodicStatesInfo));
43875 ss_VALIDATE_MEMORY(rts,statesInfo2);
43876 ssSetStatesInfo2(childS, statesInfo2);
43877 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
43878 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
43879 }
43880
43881 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
43882 RegNumInputPorts);
43883 ssSetRegNumInputPortsFcnArg(childS,childS);
43884
43885 /* inputs */
43886 {
43887 struct _ssPortInputs *inputPortInfo =
43888 (struct _ssPortInputs *) calloc(4, sizeof(struct _ssPortInputs));
43889 ss_VALIDATE_MEMORY(rts,inputPortInfo);
43890 _ssSetNumInputPorts(childS, 4);
43891 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
43892
43893 /* port 0 */
43894 {
43895 real32_T const **sfcnUPtrs = (real32_T const **)
43896 malloc(1 * sizeof(real32_T *));
43897 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43898 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
43899 ssGetLocalBlockIO(rts))->Switch_lo[1];
43900 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
43901 _ssSetInputPortNumDimensions(childS, 0, 1);
43902 ssSetInputPortWidth(childS, 0, 1);
43903 }
43904
43905 /* port 1 */
43906 {
43907 real32_T const **sfcnUPtrs = (real32_T const **)
43908 malloc(1 * sizeof(real32_T *));
43909 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43910 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
43911 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
43912 _ssSetInputPortNumDimensions(childS, 1, 1);
43913 ssSetInputPortWidth(childS, 1, 1);
43914 }
43915
43916 /* port 2 */
43917 {
43918 real32_T const **sfcnUPtrs = (real32_T const **)
43919 malloc(1 * sizeof(real32_T *));
43920 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43921 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
43922 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
43923 _ssSetInputPortNumDimensions(childS, 2, 1);
43924 ssSetInputPortWidth(childS, 2, 1);
43925 }
43926
43927 /* port 3 */
43928 {
43929 real32_T const **sfcnUPtrs = (real32_T const **)
43930 malloc(1 * sizeof(real32_T *));
43931 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
43932 sfcnUPtrs[0] = (real32_T const *)
43933 &AFCS_MODEL1_ConstP.Constant2_Value_o;
43934 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
43935 _ssSetInputPortNumDimensions(childS, 3, 1);
43936 ssSetInputPortWidth(childS, 3, 1);
43937 }
43938 }
43939
43940 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
43941 RegNumOutputPorts);
43942 ssSetRegNumOutputPortsFcnArg(childS,childS);
43943
43944 /* outputs */
43945 {
43946 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
43947 calloc(1, sizeof(struct _ssPortOutputs));
43948 ss_VALIDATE_MEMORY(rts,outputPortInfo);
43949 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
43950 _ssSetNumOutputPorts(childS, 1);
43951
43952 /* port 0 */
43953 {
43954 _ssSetOutputPortNumDimensions(childS, 0, 1);
43955 ssSetOutputPortWidth(childS, 0, 1);
43956 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
43957 ssGetLocalBlockIO(rts))->GeneratedSFunction15));
43958 }
43959 }
43960
43961 /* path info */
43962 _ssSetModelName(childS, "StickGradientDeadZone_sf");
43963 _ssSetPath(childS,
43964 "AFCS_MODEL1/AFCS_MODEL1/GNC/Pilot/Stick Gradient DeadZone2/Generated S-Function15");
43965 if (ssGetRTModel(rts) == (NULL)) {
43966 _ssSetParentSS(childS, rts);
43967 _ssSetRootSS(childS, ssGetRootSS(rts));
43968 } else {
43969 ssSetRTModel(childS,ssGetRTModel(rts));
43970 _ssSetParentSS(childS, (NULL));
43971 _ssSetRootSS(childS, childS);
43972 }
43973
43974 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
43975 (childS)->regDataType.arg1 = ((void *)(childS));
43976 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
43977 FcnSetErrorStatus);
43978 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
43979 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
43980 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
43981 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
43982
43983 /* registration */
43984#if defined(MATLAB_MEX_FILE)
43985
43986 {
43987 int_T i;
43988 mxArray *plhs[1];
43989 mxArray *prhs[4];
43990 double *pr;
43991 volatile int_T *intS = (int_T *)&childS;
43992 int_T addrlen = sizeof(SimStruct *);
43993 int_T m = addrlen/sizeof(int_T) + 1;
43994 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
43995 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
43996 pr = mxGetPr(prhs[1]);
43997 for (i = 0; i < m - 1; i++) {
43998 pr[i] = (double)intS[i];
43999 }
44000
44001 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
44002 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
44003 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
44004
44005 /* Reset port dimensions info functions because the S-function
44006 * and accelerator mex-files explicitly set their dimensions,
44007 * i.e., they are not dynamically sized. For this case, the
44008 * mex-file is responsible for the dimensions info memory
44009 * and Simulink should not free it. This is achieved by
44010 * setting the following two methods to NULL.
44011 */
44012 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
44013 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
44014
44015 /*
44016 * Setup function pointers and call mdlInitializeSizes via
44017 * simulink.c
44018 */
44019 mexCallMATLAB(1, plhs, 4, prhs, "StickGradientDeadZone_sf");
44020 mxDestroyArray(plhs[0]);
44021 mxDestroyArray(prhs[0]);
44022 mxDestroyArray(prhs[1]);
44023 mxDestroyArray(prhs[2]);
44024 mxDestroyArray(prhs[3]);
44025 }
44026
44027#else
44028
44029 {
44030 StickGradientDeadZone_sf(childS);
44031 sfcnInitializeSizes(childS);
44032 }
44033
44034#endif
44035
44036 sfcnInitializeSampleTimes(childS);
44037
44038 /* adjust sample time */
44039 ssSetSampleTime(childS, 0, 0.0);
44040 ssSetOffsetTime(childS, 0, 0.0);
44041 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
44042
44043 /* set compiled values of dynamic vector attributes */
44044 ssSetNumNonsampledZCs(childS, 0);
44045
44046 /* Update connectivity flags for each port */
44047 _ssSetInputPortConnected(childS, 0, 1);
44048 _ssSetInputPortConnected(childS, 1, 1);
44049 _ssSetInputPortConnected(childS, 2, 1);
44050 _ssSetInputPortConnected(childS, 3, 1);
44051 _ssSetOutputPortConnected(childS, 0, 1);
44052 _ssSetOutputPortBeingMerged(childS, 0, 0);
44053
44054 /* Update the BufferDstPort flags for each input port */
44055 _ssSetInputPortBufferDstPort(childS, 0, -1);
44056 _ssSetInputPortBufferDstPort(childS, 1, -1);
44057 _ssSetInputPortBufferDstPort(childS, 2, -1);
44058 _ssSetInputPortBufferDstPort(childS, 3, -1);
44059 }
44060
44061 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S305>/Generated S-Function15 (StickGradientDeadZone_sf) */
44062 {
44063 SimStruct *childS = ssGetSFunction(rts, 168);
44064
44065 /* timing info */
44066 time_T *sfcnPeriod;
44067 time_T *sfcnOffset;
44068 int_T *sfcnTsMap;
44069 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
44070 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
44071 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
44072 ss_VALIDATE_MEMORY(rts,sfcnOffset);
44073 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
44074 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
44075 (void) memset((void*)sfcnPeriod, 0,
44076 sizeof(time_T)*1);
44077 (void) memset((void*)sfcnOffset, 0,
44078 sizeof(time_T)*1);
44079 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
44080 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
44081 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
44082
44083 /* Set up the mdlInfo pointer */
44084# ifdef USE_RTMODEL
44085
44086 {
44087 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
44088 struct _ssBlkInfo2));
44089 ss_VALIDATE_MEMORY(rts,blkInfo2);
44090 ssSetBlkInfo2Ptr(childS, blkInfo2);
44091 }
44092
44093 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
44094
44095# else
44096
44097 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
44098
44099# endif /* USE_RTMODEL */
44100
44101 /* Allocate memory of model methods 2 */
44102 {
44103 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
44104 malloc(sizeof(struct _ssSFcnModelMethods2));
44105 ss_VALIDATE_MEMORY(rts,methods2);
44106 ssSetModelMethods2(childS, methods2);
44107 }
44108
44109 /* Allocate memory of model methods 3 */
44110 {
44111 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
44112 malloc(sizeof(struct _ssSFcnModelMethods3));
44113 ss_VALIDATE_MEMORY(rts,methods3);
44114 ssSetModelMethods3(childS, methods3);
44115 }
44116
44117 /* Allocate memory for states auxilliary information */
44118 {
44119 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
44120 (sizeof(struct _ssStatesInfo2));
44121 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
44122 malloc(sizeof(ssPeriodicStatesInfo));
44123 ss_VALIDATE_MEMORY(rts,statesInfo2);
44124 ssSetStatesInfo2(childS, statesInfo2);
44125 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
44126 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
44127 }
44128
44129 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
44130 RegNumInputPorts);
44131 ssSetRegNumInputPortsFcnArg(childS,childS);
44132
44133 /* inputs */
44134 {
44135 struct _ssPortInputs *inputPortInfo =
44136 (struct _ssPortInputs *) calloc(4, sizeof(struct _ssPortInputs));
44137 ss_VALIDATE_MEMORY(rts,inputPortInfo);
44138 _ssSetNumInputPorts(childS, 4);
44139 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
44140
44141 /* port 0 */
44142 {
44143 real32_T const **sfcnUPtrs = (real32_T const **)
44144 malloc(1 * sizeof(real32_T *));
44145 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
44146 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
44147 ssGetLocalBlockIO(rts))->Switch_lo[0];
44148 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
44149 _ssSetInputPortNumDimensions(childS, 0, 1);
44150 ssSetInputPortWidth(childS, 0, 1);
44151 }
44152
44153 /* port 1 */
44154 {
44155 real32_T const **sfcnUPtrs = (real32_T const **)
44156 malloc(1 * sizeof(real32_T *));
44157 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
44158 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
44159 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
44160 _ssSetInputPortNumDimensions(childS, 1, 1);
44161 ssSetInputPortWidth(childS, 1, 1);
44162 }
44163
44164 /* port 2 */
44165 {
44166 real32_T const **sfcnUPtrs = (real32_T const **)
44167 malloc(1 * sizeof(real32_T *));
44168 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
44169 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled109;
44170 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
44171 _ssSetInputPortNumDimensions(childS, 2, 1);
44172 ssSetInputPortWidth(childS, 2, 1);
44173 }
44174
44175 /* port 3 */
44176 {
44177 real32_T const **sfcnUPtrs = (real32_T const **)
44178 malloc(1 * sizeof(real32_T *));
44179 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
44180 sfcnUPtrs[0] = (real32_T const *)
44181 &AFCS_MODEL1_ConstP.Constant2_Value_o;
44182 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
44183 _ssSetInputPortNumDimensions(childS, 3, 1);
44184 ssSetInputPortWidth(childS, 3, 1);
44185 }
44186 }
44187
44188 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
44189 RegNumOutputPorts);
44190 ssSetRegNumOutputPortsFcnArg(childS,childS);
44191
44192 /* outputs */
44193 {
44194 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
44195 calloc(1, sizeof(struct _ssPortOutputs));
44196 ss_VALIDATE_MEMORY(rts,outputPortInfo);
44197 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
44198 _ssSetNumOutputPorts(childS, 1);
44199
44200 /* port 0 */
44201 {
44202 _ssSetOutputPortNumDimensions(childS, 0, 1);
44203 ssSetOutputPortWidth(childS, 0, 1);
44204 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
44205 ssGetLocalBlockIO(rts))->GeneratedSFunction15_i));
44206 }
44207 }
44208
44209 /* path info */
44210 _ssSetModelName(childS, "StickGradientDeadZone_sf");
44211 _ssSetPath(childS,
44212 "AFCS_MODEL1/AFCS_MODEL1/GNC/Pilot/Stick Gradient DeadZone1/Generated S-Function15");
44213 if (ssGetRTModel(rts) == (NULL)) {
44214 _ssSetParentSS(childS, rts);
44215 _ssSetRootSS(childS, ssGetRootSS(rts));
44216 } else {
44217 ssSetRTModel(childS,ssGetRTModel(rts));
44218 _ssSetParentSS(childS, (NULL));
44219 _ssSetRootSS(childS, childS);
44220 }
44221
44222 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
44223 (childS)->regDataType.arg1 = ((void *)(childS));
44224 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
44225 FcnSetErrorStatus);
44226 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
44227 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
44228 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
44229 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
44230
44231 /* registration */
44232#if defined(MATLAB_MEX_FILE)
44233
44234 {
44235 int_T i;
44236 mxArray *plhs[1];
44237 mxArray *prhs[4];
44238 double *pr;
44239 volatile int_T *intS = (int_T *)&childS;
44240 int_T addrlen = sizeof(SimStruct *);
44241 int_T m = addrlen/sizeof(int_T) + 1;
44242 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
44243 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
44244 pr = mxGetPr(prhs[1]);
44245 for (i = 0; i < m - 1; i++) {
44246 pr[i] = (double)intS[i];
44247 }
44248
44249 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
44250 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
44251 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
44252
44253 /* Reset port dimensions info functions because the S-function
44254 * and accelerator mex-files explicitly set their dimensions,
44255 * i.e., they are not dynamically sized. For this case, the
44256 * mex-file is responsible for the dimensions info memory
44257 * and Simulink should not free it. This is achieved by
44258 * setting the following two methods to NULL.
44259 */
44260 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
44261 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
44262
44263 /*
44264 * Setup function pointers and call mdlInitializeSizes via
44265 * simulink.c
44266 */
44267 mexCallMATLAB(1, plhs, 4, prhs, "StickGradientDeadZone_sf");
44268 mxDestroyArray(plhs[0]);
44269 mxDestroyArray(prhs[0]);
44270 mxDestroyArray(prhs[1]);
44271 mxDestroyArray(prhs[2]);
44272 mxDestroyArray(prhs[3]);
44273 }
44274
44275#else
44276
44277 {
44278 StickGradientDeadZone_sf(childS);
44279 sfcnInitializeSizes(childS);
44280 }
44281
44282#endif
44283
44284 sfcnInitializeSampleTimes(childS);
44285
44286 /* adjust sample time */
44287 ssSetSampleTime(childS, 0, 0.0);
44288 ssSetOffsetTime(childS, 0, 0.0);
44289 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
44290
44291 /* set compiled values of dynamic vector attributes */
44292 ssSetNumNonsampledZCs(childS, 0);
44293
44294 /* Update connectivity flags for each port */
44295 _ssSetInputPortConnected(childS, 0, 1);
44296 _ssSetInputPortConnected(childS, 1, 1);
44297 _ssSetInputPortConnected(childS, 2, 1);
44298 _ssSetInputPortConnected(childS, 3, 1);
44299 _ssSetOutputPortConnected(childS, 0, 1);
44300 _ssSetOutputPortBeingMerged(childS, 0, 0);
44301
44302 /* Update the BufferDstPort flags for each input port */
44303 _ssSetInputPortBufferDstPort(childS, 0, -1);
44304 _ssSetInputPortBufferDstPort(childS, 1, -1);
44305 _ssSetInputPortBufferDstPort(childS, 2, -1);
44306 _ssSetInputPortBufferDstPort(childS, 3, -1);
44307 }
44308
44309 /* RTW Generated Level2 S-Function Block: AFCS_MODEL1/<S304>/Generated S-Function15 (StickGradientDeadZone_sf) */
44310 {
44311 SimStruct *childS = ssGetSFunction(rts, 169);
44312
44313 /* timing info */
44314 time_T *sfcnPeriod;
44315 time_T *sfcnOffset;
44316 int_T *sfcnTsMap;
44317 sfcnPeriod = (time_T *) malloc(1 * sizeof(time_T));
44318 ss_VALIDATE_MEMORY(rts,sfcnPeriod);
44319 sfcnOffset = (time_T *) malloc(1 * sizeof(time_T));
44320 ss_VALIDATE_MEMORY(rts,sfcnOffset);
44321 sfcnTsMap = (int_T *) malloc(1 * sizeof(int_T ));
44322 ss_VALIDATE_MEMORY(rts,sfcnTsMap);
44323 (void) memset((void*)sfcnPeriod, 0,
44324 sizeof(time_T)*1);
44325 (void) memset((void*)sfcnOffset, 0,
44326 sizeof(time_T)*1);
44327 ssSetSampleTimePtr(childS, &sfcnPeriod[0]);
44328 ssSetOffsetTimePtr(childS, &sfcnOffset[0]);
44329 _ssSetSampleTimeTaskIDPtr(childS, sfcnTsMap);
44330
44331 /* Set up the mdlInfo pointer */
44332# ifdef USE_RTMODEL
44333
44334 {
44335 struct _ssBlkInfo2 *blkInfo2 = (struct _ssBlkInfo2 *) malloc(sizeof(
44336 struct _ssBlkInfo2));
44337 ss_VALIDATE_MEMORY(rts,blkInfo2);
44338 ssSetBlkInfo2Ptr(childS, blkInfo2);
44339 }
44340
44341 ssSetRTWSfcnInfo(childS, ssGetRTWSfcnInfo(rts));
44342
44343# else
44344
44345 _ssSetMdlInfoPtr(childS, ssGetMdlInfoPtr(rts));
44346
44347# endif /* USE_RTMODEL */
44348
44349 /* Allocate memory of model methods 2 */
44350 {
44351 struct _ssSFcnModelMethods2 *methods2 = (struct _ssSFcnModelMethods2 *)
44352 malloc(sizeof(struct _ssSFcnModelMethods2));
44353 ss_VALIDATE_MEMORY(rts,methods2);
44354 ssSetModelMethods2(childS, methods2);
44355 }
44356
44357 /* Allocate memory of model methods 3 */
44358 {
44359 struct _ssSFcnModelMethods3 *methods3 = (struct _ssSFcnModelMethods3 *)
44360 malloc(sizeof(struct _ssSFcnModelMethods3));
44361 ss_VALIDATE_MEMORY(rts,methods3);
44362 ssSetModelMethods3(childS, methods3);
44363 }
44364
44365 /* Allocate memory for states auxilliary information */
44366 {
44367 struct _ssStatesInfo2 *statesInfo2 = (struct _ssStatesInfo2 *) malloc
44368 (sizeof(struct _ssStatesInfo2));
44369 ssPeriodicStatesInfo* periodicStatesInfo = (ssPeriodicStatesInfo*)
44370 malloc(sizeof(ssPeriodicStatesInfo));
44371 ss_VALIDATE_MEMORY(rts,statesInfo2);
44372 ssSetStatesInfo2(childS, statesInfo2);
44373 ss_VALIDATE_MEMORY(rts,periodicStatesInfo);
44374 ssSetPeriodicStatesInfo(childS, periodicStatesInfo);
44375 }
44376
44377 ssSetRegNumInputPortsFcn(childS, (_ssRegNumInputPortsFcn)
44378 RegNumInputPorts);
44379 ssSetRegNumInputPortsFcnArg(childS,childS);
44380
44381 /* inputs */
44382 {
44383 struct _ssPortInputs *inputPortInfo =
44384 (struct _ssPortInputs *) calloc(4, sizeof(struct _ssPortInputs));
44385 ss_VALIDATE_MEMORY(rts,inputPortInfo);
44386 _ssSetNumInputPorts(childS, 4);
44387 ssSetPortInfoForInputs(childS, &inputPortInfo[0]);
44388
44389 /* port 0 */
44390 {
44391 real32_T const **sfcnUPtrs = (real32_T const **)
44392 malloc(1 * sizeof(real32_T *));
44393 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
44394 sfcnUPtrs[0] = (real32_T const *) &((B_AFCS_MODEL1_T *)
44395 ssGetLocalBlockIO(rts))->Switch_lo[2];
44396 _ssSetInputPortSignalPtrs(childS, 0, (InputPtrsType)&sfcnUPtrs[0]);
44397 _ssSetInputPortNumDimensions(childS, 0, 1);
44398 ssSetInputPortWidth(childS, 0, 1);
44399 }
44400
44401 /* port 1 */
44402 {
44403 real32_T const **sfcnUPtrs = (real32_T const **)
44404 malloc(1 * sizeof(real32_T *));
44405 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
44406 sfcnUPtrs[0] = (real32_T const *) &AFCS_MODEL1_ConstP.pooled116;
44407 _ssSetInputPortSignalPtrs(childS, 1, (InputPtrsType)&sfcnUPtrs[0]);
44408 _ssSetInputPortNumDimensions(childS, 1, 1);
44409 ssSetInputPortWidth(childS, 1, 1);
44410 }
44411
44412 /* port 2 */
44413 {
44414 real32_T const **sfcnUPtrs = (real32_T const **)
44415 malloc(1 * sizeof(real32_T *));
44416 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
44417 sfcnUPtrs[0] = (real32_T const *)
44418 &AFCS_MODEL1_ConstP.Constant4_Value_m;
44419 _ssSetInputPortSignalPtrs(childS, 2, (InputPtrsType)&sfcnUPtrs[0]);
44420 _ssSetInputPortNumDimensions(childS, 2, 1);
44421 ssSetInputPortWidth(childS, 2, 1);
44422 }
44423
44424 /* port 3 */
44425 {
44426 real32_T const **sfcnUPtrs = (real32_T const **)
44427 malloc(1 * sizeof(real32_T *));
44428 ss_VALIDATE_MEMORY(rts,sfcnUPtrs);
44429 sfcnUPtrs[0] = (real32_T const *)
44430 &AFCS_MODEL1_ConstP.Constant2_Value_o;
44431 _ssSetInputPortSignalPtrs(childS, 3, (InputPtrsType)&sfcnUPtrs[0]);
44432 _ssSetInputPortNumDimensions(childS, 3, 1);
44433 ssSetInputPortWidth(childS, 3, 1);
44434 }
44435 }
44436
44437 ssSetRegNumOutputPortsFcn(childS, (_ssRegNumOutputPortsFcn)
44438 RegNumOutputPorts);
44439 ssSetRegNumOutputPortsFcnArg(childS,childS);
44440
44441 /* outputs */
44442 {
44443 struct _ssPortOutputs *outputPortInfo = (struct _ssPortOutputs *)
44444 calloc(1, sizeof(struct _ssPortOutputs));
44445 ss_VALIDATE_MEMORY(rts,outputPortInfo);
44446 ssSetPortInfoForOutputs(childS, &outputPortInfo[0]);
44447 _ssSetNumOutputPorts(childS, 1);
44448
44449 /* port 0 */
44450 {
44451 _ssSetOutputPortNumDimensions(childS, 0, 1);
44452 ssSetOutputPortWidth(childS, 0, 1);
44453 _ssSetOutputPortSignal(childS, 0, ((real32_T *) &((B_AFCS_MODEL1_T *)
44454 ssGetLocalBlockIO(rts))->GeneratedSFunction15_e));
44455 }
44456 }
44457
44458 /* path info */
44459 _ssSetModelName(childS, "StickGradientDeadZone_sf");
44460 _ssSetPath(childS,
44461 "AFCS_MODEL1/AFCS_MODEL1/GNC/Pilot/Stick Gradient DeadZone/Generated S-Function15");
44462 if (ssGetRTModel(rts) == (NULL)) {
44463 _ssSetParentSS(childS, rts);
44464 _ssSetRootSS(childS, ssGetRootSS(rts));
44465 } else {
44466 ssSetRTModel(childS,ssGetRTModel(rts));
44467 _ssSetParentSS(childS, (NULL));
44468 _ssSetRootSS(childS, childS);
44469 }
44470
44471 ssSetVersion(childS, SIMSTRUCT_VERSION_LEVEL2);
44472 (childS)->regDataType.arg1 = ((void *)(childS));
44473 (childS)->regDataType.registerFcn = ((OldRegisterDataType)
44474 FcnSetErrorStatus);
44475 (childS)->regDataType.getSizeFcn = ((GetDataTypeSize)FcnSetErrorStatus);
44476 (childS)->regDataType.getZeroFcn = ((GetDataTypeZero)FcnSetErrorStatus);
44477 (childS)->regDataType.getNameFcn = ((GetDataTypeName)FcnSetErrorStatus);
44478 (childS)->regDataType.getIdFcn = ((GetDataTypeId)FcnSetErrorStatus);
44479
44480 /* registration */
44481#if defined(MATLAB_MEX_FILE)
44482
44483 {
44484 int_T i;
44485 mxArray *plhs[1];
44486 mxArray *prhs[4];
44487 double *pr;
44488 volatile int_T *intS = (int_T *)&childS;
44489 int_T addrlen = sizeof(SimStruct *);
44490 int_T m = addrlen/sizeof(int_T) + 1;
44491 prhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
44492 prhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
44493 pr = mxGetPr(prhs[1]);
44494 for (i = 0; i < m - 1; i++) {
44495 pr[i] = (double)intS[i];
44496 }
44497
44498 pr[i] = (double)SIMSTRUCT_VERSION_LEVEL2;
44499 prhs[2] = mxCreateDoubleMatrix(0,0,mxREAL);
44500 prhs[3] = mxCreateDoubleMatrix(1,1,mxREAL);
44501
44502 /* Reset port dimensions info functions because the S-function
44503 * and accelerator mex-files explicitly set their dimensions,
44504 * i.e., they are not dynamically sized. For this case, the
44505 * mex-file is responsible for the dimensions info memory
44506 * and Simulink should not free it. This is achieved by
44507 * setting the following two methods to NULL.
44508 */
44509 ssSetRegInputPortDimensionInfoFcn(childS, (NULL));
44510 ssSetRegOutputPortDimensionInfoFcn(childS, (NULL));
44511
44512 /*
44513 * Setup function pointers and call mdlInitializeSizes via
44514 * simulink.c
44515 */
44516 mexCallMATLAB(1, plhs, 4, prhs, "StickGradientDeadZone_sf");
44517 mxDestroyArray(plhs[0]);
44518 mxDestroyArray(prhs[0]);
44519 mxDestroyArray(prhs[1]);
44520 mxDestroyArray(prhs[2]);
44521 mxDestroyArray(prhs[3]);
44522 }
44523
44524#else
44525
44526 {
44527 StickGradientDeadZone_sf(childS);
44528 sfcnInitializeSizes(childS);
44529 }
44530
44531#endif
44532
44533 sfcnInitializeSampleTimes(childS);
44534
44535 /* adjust sample time */
44536 ssSetSampleTime(childS, 0, 0.0);
44537 ssSetOffsetTime(childS, 0, 0.0);
44538 sfcnTsMap[0] = ssGetSampleTimeTaskIDPtr(rts)[0];
44539
44540 /* set compiled values of dynamic vector attributes */
44541 ssSetNumNonsampledZCs(childS, 0);
44542
44543 /* Update connectivity flags for each port */
44544 _ssSetInputPortConnected(childS, 0, 1);
44545 _ssSetInputPortConnected(childS, 1, 1);
44546 _ssSetInputPortConnected(childS, 2, 1);
44547 _ssSetInputPortConnected(childS, 3, 1);
44548 _ssSetOutputPortConnected(childS, 0, 1);
44549 _ssSetOutputPortBeingMerged(childS, 0, 0);
44550
44551 /* Update the BufferDstPort flags for each input port */
44552 _ssSetInputPortBufferDstPort(childS, 0, -1);
44553 _ssSetInputPortBufferDstPort(childS, 1, -1);
44554 _ssSetInputPortBufferDstPort(childS, 2, -1);
44555 _ssSetInputPortBufferDstPort(childS, 3, -1);
44556 }
44557 }
44558 }
44559
44560 return (NULL);
44561}
44562